upstream/upstream-tanstack-query
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

snapshot of https://github.com/TanStack/query.git (main, 2026-09-16; blobs > 131072B omitted)
Some checks failed
autofix.ci / autofix (push) Failing after 4s
Details
Release / Release (push) Has been skipped
Details
GitHub Actions Security Analysis / Run zizmor (push) Failing after 2s
Details

Browse Source
This commit is contained in:
upstream-mirror
2026-09-16 01:13:08 +05:00
commit 3a013ccdfe
3570 changed files with 490194 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
docs/framework/svelte/devtools.md Normal file
View File

@@ -0,0 +1,81 @@
---
id: devtools
title: Devtools
---
> For Chrome, Firefox, and Edge users: Third-party browser extensions are available for debugging TanStack Query directly in browser DevTools. These provide the same functionality as the framework-specific devtools packages:
>
> - <img alt="Chrome logo" src="https://www.google.com/chrome/static/images/chrome-logo.svg" width="16" height="16" class="inline mr-1 not-prose" /> <a href="https://chromewebstore.google.com/detail/tanstack-query-devtools/annajfchloimdhceglpgglpeepfghfai">Devtools for Chrome</a>
> - <img alt="Firefox logo" src="https://upload.wikimedia.org/wikipedia/commons/a/a0/Firefox_logo%2C_2019.svg" width="16" height="16" class="inline mr-1 not-prose" /> <a href="https://addons.mozilla.org/en-US/firefox/addon/tanstack-query-devtools/">Devtools for Firefox</a>
> - <img alt="Edge logo" src="https://upload.wikimedia.org/wikipedia/commons/9/98/Microsoft_Edge_logo_%282019%29.svg" width="16" height="16" class="inline mr-1 not-prose" /> <a href="https://microsoftedge.microsoft.com/addons/detail/tanstack-query-devtools/edmdpkgkacmjopodhfolmphdenmddobj">Devtools for Edge</a>
## Install and Import the Devtools
The devtools are a separate package that you need to install:
```bash
npm i @tanstack/svelte-query-devtools
```
or
```bash
pnpm add @tanstack/svelte-query-devtools
```
or
```bash
yarn add @tanstack/svelte-query-devtools
```
or
```bash
bun add @tanstack/svelte-query-devtools
```
You can import the devtools like this:
```ts
import { SvelteQueryDevtools } from '@tanstack/svelte-query-devtools'
```
## Floating Mode
Floating Mode will mount the devtools as a fixed, floating element in your app and provide a toggle in the corner of the screen to show and hide the devtools. This toggle state will be stored and remembered in localStorage across reloads.
Place the following code as high in your Svelte app as you can. The closer it is to the root of the page, the better it will work!
```ts
<script>
import { QueryClientProvider } from '@tanstack/svelte-query'
import { SvelteQueryDevtools } from '@tanstack/svelte-query-devtools'
</script>
<QueryClientProvider client={queryClient}>
{/* The rest of your application */}
<SvelteQueryDevtools />
</QueryClientProvider>
```
### Options
- `initialIsOpen: boolean`
- Set this `true` if you want the dev tools to default to being open
- `buttonPosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right" | "relative"`
- Defaults to `bottom-right`
- The position of the TanStack logo to open and close the devtools panel
- If `relative`, the button is placed in the location that you render the devtools.
- `position?: "top" | "bottom" | "left" | "right"`
- Defaults to `bottom`
- The position of the Svelte Query devtools panel
- `client?: QueryClient`,
- Use this to use a custom QueryClient. Otherwise, the one from the nearest context will be used.
- `errorTypes?: { name: string; initializer: (query: Query) => TError}[]`
- Use this to predefine some errors that can be triggered on your queries. Initializer will be called (with the specific query) when that error is toggled on from the UI. It must return an Error.
- `styleNonce?: string`
- Use this to pass a nonce to the style tag that is added to the document head. This is useful if you are using a Content Security Policy (CSP) nonce to allow inline styles.
- `shadowDOMTarget?: ShadowRoot`
- Default behavior will apply the devtool's styles to the head tag within the DOM.
- Use this to pass a shadow DOM target to the devtools so that the styles will be applied within the shadow DOM instead of within the head tag in the light DOM.

32
docs/framework/svelte/installation.md Normal file
View File

@@ -0,0 +1,32 @@
---
id: installation
title: Installation
---
You can install Svelte Query via [NPM](https://npmjs.com).
### NPM
```bash
npm i @tanstack/svelte-query
```
or
```bash
pnpm add @tanstack/svelte-query
```
or
```bash
yarn add @tanstack/svelte-query
```
or
```bash
bun add @tanstack/svelte-query
```
> Wanna give it a spin before you download? Try out the [basic](./examples/basic) example!

76
docs/framework/svelte/migrate-from-v5-to-v6.md Normal file
View File

@@ -0,0 +1,76 @@
While Svelte v5 has legacy compatibility with the stores syntax from Svelte v3/v4, it has been somewhat buggy and unreliable for this adapter. The `@tanstack/svelte-query` v6 adapter fully migrates to the runes syntax, which relies on signals. This rewrite should also simplify the code required to ensure your query inputs remain reactive.
## Installation
Please ensure your project has [Svelte v5.25.0](https://github.com/sveltejs/svelte/releases/tag/svelte%405.25.0) or newer.
Run `pnpm add @tanstack/svelte-query@latest` (or your package manager's equivalent).
> Note that `@tanstack/svelte-query` v6 depends on `@tanstack/query-core` v5.
## Function Inputs
Like the Angular and Solid adapters, most functions for the Svelte adapter now require options to be provided as a "thunk" (`() => options`) to provide reactivity. TypeScript will be your friend here and warn you if you're missing this notation.
```ts
- const query = createQuery({ // [!code --]
+ const query = createQuery(() => ({ // [!code ++]
queryKey: ['todos'],
queryFn: () => fetchTodos(),
- }) // [!code --]
+ })) // [!code ++]
```
## Accessing Properties
Given the adapter no longer uses stores, it is no longer necessary to prefix with `$`.
```svelte
- {#if $todos.isSuccess} // [!code --]
+ {#if todos.isSuccess} // [!code ++]
<ul>
- {#each $todos.data.items as item} // [!code --]
+ {#each todos.data.items as item} // [!code ++]
<li>{item}</li>
{/each}
</ul>
{/if}
```
## Reactivity
You previously needed to do some funky things with stores to achieve reactivity for inputs. This is no longer the case! You don't even need to wrap your query in a `$derived`.
```ts
- const intervalMs = writable(1000) // [!code --]
+ let intervalMs = $state(1000) // [!code ++]
- const query = createQuery(derived(intervalMs, ($intervalMs) => ({ // [!code --]
+ const query = createQuery(() => ({ // [!code ++]
queryKey: ['refetch'],
queryFn: async () => await fetch('/api/data').then((r) => r.json()),
- refetchInterval: $intervalMs, // [!code --]
+ refetchInterval: intervalMs, // [!code ++]
- }))) // [!code --]
+ })) // [!code ++]
```
## Disabling Legacy Mode
If your component has any stores, it might not properly switch to runes mode. You can ensure your application is using runes in two ways:
### On a per-file basis
In each `.svelte` file, once you have migrated to runes, add `<svelte:options runes={true} />`. This is better for large applications requiring gradual migration.
### On an project-wide basis
In your `svelte.config.js`, add the following to config:
```json
compilerOptions: {
runes: true,
},
```
This can be added once you've 100% eradicated stores syntax from your app.

77
docs/framework/svelte/overview.md Normal file
View File

@@ -0,0 +1,77 @@
---
id: overview
title: Overview
---
The `@tanstack/svelte-query` package offers a 1st-class API for using TanStack Query via Svelte.
> Migrating from stores to the runes syntax? See the [migration guide](./migrate-from-v5-to-v6).
## Example
Include the QueryClientProvider near the root of your project:
```svelte
<script lang="ts">
import { QueryClient, QueryClientProvider } from '@tanstack/svelte-query'
import Example from './lib/Example.svelte'
const queryClient = new QueryClient()
</script>
<QueryClientProvider client={queryClient}>
<Example />
</QueryClientProvider>
```
Then call any function (e.g. createQuery) from any component:
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['todos'],
queryFn: () => fetchTodos(),
}))
</script>
<div>
{#if query.isPending}
<p>Loading...</p>
{:else if query.isError}
<p>Error: {query.error.message}</p>
{:else if query.isSuccess}
{#each query.data as todo}
<p>{todo.title}</p>
{/each}
{/if}
</div>
```
## SvelteKit
If you are using SvelteKit, please have a look at [SSR & SvelteKit](./ssr).
## Available Functions
Svelte Query offers useful functions and components that will make managing server state in Svelte apps easier.
- `createQuery`
- `createQueries`
- `createInfiniteQuery`
- `createMutation`
- `useQueryClient`
- `useIsFetching`
- `useIsMutating`
- `useMutationState`
- `useIsRestoring`
- `useHydrate`
- `<QueryClientProvider>`
- `<HydrationBoundary>`
## Important Differences between Svelte Query & React Query
Svelte Query offers an API similar to React Query, but there are some key differences to be mindful of.
- The arguments to the `create*` functions must be wrapped in a function to preserve reactivity.

151
docs/framework/svelte/quick-start.md Normal file
View File

@@ -0,0 +1,151 @@
---
id: quick-start
title: Quick Start
---
The `@tanstack/svelte-query` package offers a 1st-class API for using TanStack Query via Svelte.
## Example
```svelte
<script lang="ts">
import { QueryClient, QueryClientProvider } from '@tanstack/svelte-query'
import Example from './lib/Example.svelte'
const queryClient = new QueryClient()
</script>
<QueryClientProvider client={queryClient}>
<Example />
</QueryClientProvider>
```
Then call any function (e.g. createQuery) from any component:
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['todos'],
queryFn: () => fetchTodos(),
}))
</script>
<div>
{#if query.isPending}
<p>Loading...</p>
{:else if query.isError}
<p>Error: {query.error.message}</p>
{:else if query.isSuccess}
{#each query.data as todo}
<p>{todo.title}</p>
{/each}
{/if}
</div>
```
## Important Differences between Svelte Query & React Query
Svelte Query offers an API similar to React Query, but there are some key differences to be mindful of.
- Arguments to `svelte-query` primitives (like `createQuery`, `createMutation`) are functions, so that they can be tracked in a reactive scope.
```ts
// ❌ react version
useQuery({
queryKey: ['todos', todo],
queryFn: fetchTodos,
})
// ✅ svelte version
createQuery(() => ({
queryKey: ['todos', todo],
queryFn: fetchTodos,
}))
```
- Svelte Query primitives do not support destructuring. The return value from these functions is a proxy, and their properties are dynamically resolved.
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['repoData'],
queryFn: () =>
fetch('https://api.github.com/repos/tannerlinsley/react-query').then(
(res) => res.json(),
),
}))
</script>
<!-- ❌ react version -- supports destructuring outside reactive context
const { isPending, error, data } = useQuery({
queryKey: ['repoData'],
queryFn: () =>
fetch('https://api.github.com/repos/tannerlinsley/react-query').then(
(res) => res.json(),
),
}) -->
<!-- ✅ access query properties in svelte reactive context -->
<div>
{#if query.isPending}
<p>Loading...</p>
{:else if query.isError}
<p>Error: {query.error.message}</p>
{:else if query.isSuccess}
<div>
<h1>{query.data.name}</h1>
<p>{query.data.description}</p>
<strong>👀 {query.data.subscribers_count}</strong>
<strong>✨ {query.data.stargazers_count}</strong>
<strong>🍴 {query.data.forks_count}</strong>
</div>
{/if}
</div>
```
- Runes values can be passed in directly to function arguments. Svelte Query will update the query automatically.
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
let enabled = $state(false)
let todoCount = $state(0)
// ✅ passing a rune directly is safe and observers update
// automatically when the value of a rune changes
const todosQuery = createQuery(() => ({
queryKey: ['todos'],
queryFn: () => fetchTodos(),
enabled: enabled,
}))
const todoDetailsQuery = createQuery(() => ({
queryKey: ['todo', todoCount],
queryFn: fetchTodo,
enabled: todoCount > 0,
}))
</script>
<div>
{#if todosQuery.isPending}
<p>Loading...</p>
{:else if todosQuery.isError}
<p>Error: {todosQuery.error.message}</p>
{:else if todosQuery.isSuccess}
{#each todosQuery.data as todo}
<button onclick={() => (todoCount = todo.id)}>{todo.title}</button>
{/each}
{/if}
<button onclick={() => (enabled = !enabled)}>Toggle enabled</button>
</div>
```
- Errors can be caught and reset using Svelte's native `<svelte:boundary>` component.
Set `throwOnError` option to `true` to make sure errors are thrown to the `<svelte:boundary>` component.
- Since property tracking is handled through Svelte's fine-grained reactivity, options like `notifyOnChangeProps` are not needed

273
docs/framework/svelte/reference/classes/CancelledError.md Normal file
View File

@@ -0,0 +1,273 @@
---
id: CancelledError
title: CancelledError
---
Defined in: [packages/query-core/src/retryer.ts:77](https://github.com/TanStack/query/blob/main/packages/query-core/src/retryer.ts#L77)
The error thrown by a `Retryer` (and surfaced to `query.promise`/`mutation`) when a fetch is cancelled, e.g. via
`query.cancel()`. `revert`, if `true`, tells the caller to restore the state the query was in before the fetch
started instead of surfacing the error. `silent`, if `true`, tells the caller to suppress this error and instead
resolve with the promise of the fetch that triggered the cancellation.
## Example
```ts
query.cancel()
try {
await query.promise
} catch (error) {
if (error instanceof CancelledError) {
// the fetch was cancelled, e.g. via `query.cancel()`
}
}
```
## Extends
- `Error`
## Constructors
### Constructor
```ts
new CancelledError(options?): CancelledError;
```
Defined in: [packages/query-core/src/retryer.ts:80](https://github.com/TanStack/query/blob/main/packages/query-core/src/retryer.ts#L80)
#### Parameters
##### options?
[`CancelOptions`](../interfaces/CancelOptions.md)
#### Returns
`CancelledError`
#### Overrides
```ts
Error.constructor
```
## Properties
### cause?
```ts
optional cause: unknown;
```
Defined in: node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24
#### Inherited from
```ts
Error.cause
```
***
### message
```ts
message: string;
```
Defined in: node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075
#### Inherited from
```ts
Error.message
```
***
### name
```ts
name: string;
```
Defined in: node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074
#### Inherited from
```ts
Error.name
```
***
### revert?
```ts
optional revert: boolean;
```
Defined in: [packages/query-core/src/retryer.ts:78](https://github.com/TanStack/query/blob/main/packages/query-core/src/retryer.ts#L78)
***
### silent?
```ts
optional silent: boolean;
```
Defined in: [packages/query-core/src/retryer.ts:79](https://github.com/TanStack/query/blob/main/packages/query-core/src/retryer.ts#L79)
***
### stack?
```ts
optional stack: string;
```
Defined in: node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076
#### Inherited from
```ts
Error.stack
```
***
### stackTraceLimit
```ts
static stackTraceLimit: number;
```
Defined in: node\_modules/.pnpm/@types+node@22.19.15/node\_modules/@types/node/globals.d.ts:68
The `Error.stackTraceLimit` property specifies the number of stack frames
collected by a stack trace (whether generated by `new Error().stack` or
`Error.captureStackTrace(obj)`).
The default value is `10` but may be set to any valid JavaScript number. Changes
will affect any stack trace captured _after_ the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will
not capture any frames.
#### Inherited from
```ts
Error.stackTraceLimit
```
## Methods
### captureStackTrace()
```ts
static captureStackTrace(targetObject, constructorOpt?): void;
```
Defined in: node\_modules/.pnpm/@types+node@22.19.15/node\_modules/@types/node/globals.d.ts:52
Creates a `.stack` property on `targetObject`, which when accessed returns
a string representing the location in the code at which
`Error.captureStackTrace()` was called.
```js
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
```
The first line of the trace will be prefixed with
`${myObject.name}: ${myObject.message}`.
The optional `constructorOpt` argument accepts a function. If given, all frames
above `constructorOpt`, including `constructorOpt`, will be omitted from the
generated stack trace.
The `constructorOpt` argument is useful for hiding implementation
details of error generation from the user. For instance:
```js
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
```
#### Parameters
##### targetObject
`object`
##### constructorOpt?
`Function`
#### Returns
`void`
#### Inherited from
```ts
Error.captureStackTrace
```
***
### prepareStackTrace()
```ts
static prepareStackTrace(err, stackTraces): any;
```
Defined in: node\_modules/.pnpm/@types+node@22.19.15/node\_modules/@types/node/globals.d.ts:56
#### Parameters
##### err
`Error`
##### stackTraces
`CallSite`[]
#### Returns
`any`
#### See
https://v8.dev/docs/stack-trace-api#customizing-stack-traces
#### Inherited from
```ts
Error.prepareStackTrace
```

665
docs/framework/svelte/reference/classes/InfiniteQueryObserver.md Normal file
View File

@@ -0,0 +1,665 @@
---
id: InfiniteQueryObserver
title: InfiniteQueryObserver
---
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:41](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L41)
An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
between infinite queries. It augments the base `QueryObserverResult` with
infinite-query-specific fields and methods, such as `hasNextPage` and
`fetchNextPage`, and is the primitive that framework adapters (e.g.
`useInfiniteQuery`) build their hooks on top of.
## Example
```ts
const observer = new InfiniteQueryObserver(queryClient, {
queryKey: ['projects'],
queryFn: ({ pageParam }) => fetchProjects(pageParam),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextCursor,
})
const unsubscribe = observer.subscribe((result) => console.log(result))
```
## Extends
- [`QueryObserver`](QueryObserver.md)\<`TQueryFnData`, `TError`, `TData`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `TPageParam`\>, `TQueryKey`\>
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`\>
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `unknown`
## Constructors
### Constructor
```ts
new InfiniteQueryObserver<TQueryFnData, TError, TData, TQueryKey, TPageParam>(client, options): InfiniteQueryObserver<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:83](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L83)
#### Parameters
##### client
[`QueryClient`](QueryClient.md)
##### options
[`InfiniteQueryObserverOptions`](../interfaces/InfiniteQueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
#### Returns
`InfiniteQueryObserver`\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
#### Overrides
[`QueryObserver`](QueryObserver.md).[`constructor`](QueryObserver.md#constructor)
## Properties
### fetch
```ts
protected fetch: ReplaceReturnType<(fetchOptions) => Promise<QueryObserverResult<TData, TError>>, Promise<InfiniteQueryObserverResult<TData, TError>>>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:72](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L72)
#### Overrides
```ts
QueryObserver.fetch
```
***
### getCurrentResult
```ts
getCurrentResult: ReplaceReturnType<() => QueryObserverResult<TData, TError>, InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:60](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L60)
Returns the most recently computed `QueryObserverResult` for the
observed query. This is a point-in-time read; to be notified of updates
as they happen, subscribe to the observer instead (its inherited
`subscribe` method).
#### Example
```ts
const result = observer.getCurrentResult()
console.log(result.status, result.data)
```
#### Overrides
```ts
QueryObserver.getCurrentResult
```
***
### listeners
```ts
protected listeners: Set<QueryObserverListener<TData, TError>>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`listeners`](QueryObserver.md#listeners)
***
### options
```ts
options: QueryObserverOptions<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/queryObserver.ts:89](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L89)
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`options`](QueryObserver.md#options)
***
### subscribe()
```ts
subscribe: (listener) => () => void;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:55](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L55)
#### Parameters
##### listener
`InfiniteQueryObserverListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Overrides
```ts
QueryObserver.subscribe
```
## Methods
### bindMethods()
```ts
protected bindMethods(): void;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:96](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L96)
#### Returns
`void`
#### Overrides
[`QueryObserver`](QueryObserver.md).[`bindMethods`](QueryObserver.md#bindmethods)
***
### createResult()
```ts
protected createResult(query, options): InfiniteQueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:201](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L201)
#### Parameters
##### query
[`Query`](Query.md)\<`TQueryFnData`, `TError`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `TPageParam`\>, `TQueryKey`\>
##### options
[`InfiniteQueryObserverOptions`](../interfaces/InfiniteQueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
#### Returns
[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>
#### Overrides
[`QueryObserver`](QueryObserver.md).[`createResult`](QueryObserver.md#createresult)
***
### destroy()
```ts
destroy(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:161](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L161)
Stops observing the current query: clears all listeners, cancels the
stale and refetch-interval timers, and removes this observer from the
query it was observing.
#### Returns
`void`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`destroy`](QueryObserver.md#destroy)
***
### fetchNextPage()
```ts
fetchNextPage(options?): Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:161](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L161)
Fetches the next page of the infinite query and returns a promise that
resolves with the resulting `InfiniteQueryObserverResult`. The page
param used for the fetch is determined by `getNextPageParam`, which
receives the current pages/page params and whose result also determines
`hasNextPage`.
#### Parameters
##### options?
[`FetchNextPageOptions`](../interfaces/FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const { hasNextPage } = observer.getCurrentResult()
if (hasNextPage) {
await observer.fetchNextPage()
}
```
#### See
[InfiniteQueryObserver#fetchPreviousPage](#fetchpreviouspage)
***
### fetchOptimistic()
```ts
fetchOptimistic(options): Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/queryObserver.ts:395](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L395)
Fetches a query defined by the given options without affecting this
observer's own tracked query or result, and returns a promise that
resolves with the `QueryObserverResult` for that fetch. This is useful
for prefetching data that another observer (e.g. a query about to be
navigated to) will need, ahead of time.
#### Parameters
##### options
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `TPageParam`\>, `TQueryKey`\>
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const result = await observer.fetchOptimistic({
queryKey: ['posts', 2],
queryFn: () => fetchPost(2),
})
console.log(result.data)
```
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`fetchOptimistic`](QueryObserver.md#fetchoptimistic)
***
### fetchPreviousPage()
```ts
fetchPreviousPage(options?): Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:190](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L190)
Fetches the previous page of the infinite query and returns a promise
that resolves with the resulting `InfiniteQueryObserverResult`. The page
param used for the fetch is determined by `getPreviousPageParam`, which
receives the current pages/page params and whose result also determines
`hasPreviousPage`.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](../interfaces/FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const { hasPreviousPage } = observer.getCurrentResult()
if (hasPreviousPage) {
await observer.fetchPreviousPage()
}
```
#### See
[InfiniteQueryObserver#fetchNextPage](#fetchnextpage)
***
### getCurrentQuery()
```ts
getCurrentQuery(): Query<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/queryObserver.ts:357](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L357)
Returns the `Query` instance this observer is currently observing.
#### Returns
[`Query`](Query.md)\<`TQueryFnData`, `TError`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `TPageParam`\>, `TQueryKey`\>
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`getCurrentQuery`](QueryObserver.md#getcurrentquery)
***
### getOptimisticResult()
```ts
getOptimisticResult(options): InfiniteQueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:127](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L127)
The infinite-query counterpart of [QueryObserver#getOptimisticResult](QueryObserver.md#getoptimisticresult), marking the
options as an infinite query before delegating to it. Called by framework adapters (e.g.
`useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
synchronously.
#### Parameters
##### options
[`DefaultedInfiniteQueryObserverOptions`](../type-aliases/DefaultedInfiniteQueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
#### Returns
[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>
#### Overrides
[`QueryObserver`](QueryObserver.md).[`getOptimisticResult`](QueryObserver.md#getoptimisticresult)
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`hasListeners`](QueryObserver.md#haslisteners)
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:110](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L110)
#### Returns
`void`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`onSubscribe`](QueryObserver.md#onsubscribe)
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:124](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L124)
#### Returns
`void`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`onUnsubscribe`](QueryObserver.md#onunsubscribe)
***
### refetch()
```ts
refetch(__namedParameters): Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/queryObserver.ts:371](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L371)
Refetches the observed query and returns a promise that resolves with
the resulting `QueryObserverResult`.
#### Parameters
##### \_\_namedParameters
[`RefetchOptions`](../interfaces/RefetchOptions.md) = `{}`
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const result = await observer.refetch({ cancelRefetch: false })
console.log(result.data)
```
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`refetch`](QueryObserver.md#refetch)
***
### setOptions()
```ts
setOptions(options): void;
```
Defined in: [packages/query-core/src/infiniteQueryObserver.ts:108](https://github.com/TanStack/query/blob/main/packages/query-core/src/infiniteQueryObserver.ts#L108)
Updates the observer's options. Behaves the same as
`QueryObserver.setOptions`, additionally marking the options as
belonging to an infinite query before delegating to the base
implementation.
#### Parameters
##### options
[`InfiniteQueryObserverOptions`](../interfaces/InfiniteQueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
#### Returns
`void`
#### Overrides
[`QueryObserver`](QueryObserver.md).[`setOptions`](QueryObserver.md#setoptions)
***
### shouldFetchOnReconnect()
```ts
shouldFetchOnReconnect(): boolean;
```
Defined in: [packages/query-core/src/queryObserver.ts:135](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L135)
Returns whether the observed query is currently stale and configured
(via the `refetchOnReconnect` option) to refetch when the network
reconnects.
#### Returns
`boolean`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`shouldFetchOnReconnect`](QueryObserver.md#shouldfetchonreconnect)
***
### shouldFetchOnWindowFocus()
```ts
shouldFetchOnWindowFocus(): boolean;
```
Defined in: [packages/query-core/src/queryObserver.ts:148](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L148)
Returns whether the observed query is currently stale and configured
(via the `refetchOnWindowFocus` option) to refetch when the window
regains focus.
#### Returns
`boolean`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`shouldFetchOnWindowFocus`](QueryObserver.md#shouldfetchonwindowfocus)
***
### trackProp()
```ts
trackProp(key): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:350](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L350)
Records that the given `QueryObserverResult` property was read, so a subsequent update only
notifies this observer if a tracked property actually changed. Normally called indirectly via
[QueryObserver#trackResult](QueryObserver.md#trackresult)'s proxy; exposed directly for adapters that track property
access themselves (e.g. through their own reactivity system) instead of via the proxy.
#### Parameters
##### key
`"error"` | `"data"` | `"isError"` | `"isPending"` | `"isLoading"` | `"isLoadingError"` | `"isRefetchError"` | `"isSuccess"` | `"isPlaceholderData"` | `"status"` | `"dataUpdatedAt"` | `"errorUpdatedAt"` | `"failureCount"` | `"failureReason"` | `"errorUpdateCount"` | `"isFetched"` | `"isFetchedAfterMount"` | `"isFetching"` | `"isInitialLoading"` | `"isPaused"` | `"isRefetching"` | `"isStale"` | `"isEnabled"` | `"refetch"` | `"fetchStatus"`
#### Returns
`void`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`trackProp`](QueryObserver.md#trackprop)
***
### trackResult()
```ts
trackResult(result, onPropTracked?): QueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/queryObserver.ts:331](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L331)
Wraps a `QueryObserverResult` in a `Proxy` that records which properties are read, via
[QueryObserver#trackProp](QueryObserver.md#trackprop) (and an optional `onPropTracked` callback). Used by framework
adapters when `notifyOnChangeProps` is not set, to implement its default "only re-render on
properties you actually read" behavior.
#### Parameters
##### result
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
##### onPropTracked?
(`key`) => `void`
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`trackResult`](QueryObserver.md#trackresult)
***
### updateResult()
```ts
updateResult(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:735](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L735)
Recomputes and stores the current result from the current query/options, notifying listeners
if it changed. Framework adapters call this right after subscribing to make sure no query
update was missed in the gap between creating the observer and subscribing to it.
#### Returns
`void`
#### Inherited from
[`QueryObserver`](QueryObserver.md).[`updateResult`](QueryObserver.md#updateresult)

330
docs/framework/svelte/reference/classes/Mutation.md Normal file
View File

@@ -0,0 +1,330 @@
---
id: Mutation
title: Mutation
---
Defined in: [packages/query-core/src/mutation.ts:135](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L135)
Represents a single mutation attempt. A `Mutation` holds the mutation's
options, state (data/error/status), and the `MutationObserver`s currently
subscribed to it.
Instances are created and managed internally by `MutationCache`; application
code typically interacts with mutations indirectly through `QueryClient` or
a framework hook like `useMutation`. Direct access to a `Mutation` instance
is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.
## Example
```ts
const mutationCache = queryClient.getMutationCache()
const mutation = mutationCache.find({ mutationKey: ['addPost'] })
```
## Extends
- `Removable`
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `unknown`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Constructors
### Constructor
```ts
new Mutation<TData, TError, TVariables, TOnMutateResult>(config): Mutation<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutation.ts:152](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L152)
#### Parameters
##### config
`MutationConfig`\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Returns
`Mutation`\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Overrides
```ts
Removable.constructor
```
## Properties
### gcTime
```ts
gcTime: number;
```
Defined in: [packages/query-core/src/removable.ts:7](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L7)
#### Inherited from
```ts
Removable.gcTime
```
***
### mutationId
```ts
readonly mutationId: number;
```
Defined in: [packages/query-core/src/mutation.ts:143](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L143)
***
### options
```ts
options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutation.ts:142](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L142)
***
### state
```ts
state: MutationState<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutation.ts:141](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L141)
## Accessors
### meta
#### Get Signature
```ts
get meta(): Record<string, unknown> | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:179](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L179)
The `meta` object passed in the mutation's options, if any.
##### Returns
`Record`\<`string`, `unknown`\> \| `undefined`
## Methods
### clearGcTimeout()
```ts
protected clearGcTimeout(): void;
```
Defined in: [packages/query-core/src/removable.ts:32](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L32)
#### Returns
`void`
#### Inherited from
```ts
Removable.clearGcTimeout
```
***
### continue()
```ts
continue(): Promise<unknown>;
```
Defined in: [packages/query-core/src/mutation.ts:243](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L243)
Resumes a mutation that is currently paused or was restored from a
dehydrated, still-`pending` state.
- If this mutation has an active retryer (it paused mid-attempt, e.g. due
to the network mode or scope-based queuing), its retryer is resumed.
- Otherwise, if the mutation's status is still `pending` (e.g. it was
dehydrated while an attempt was in flight and never got a retryer in
this instance), `execute` is called again with the last known variables.
- Otherwise the mutation has already settled and this resolves immediately
without running anything again.
#### Returns
`Promise`\<`unknown`\>
#### Example
```ts
// typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()
const mutation = mutationCache.find({ mutationKey: ['addPost'] })
await mutation?.continue()
```
#### See
[Mutation#execute](#execute)
***
### destroy()
```ts
destroy(): void;
```
Defined in: [packages/query-core/src/removable.ts:10](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L10)
#### Returns
`void`
#### Inherited from
```ts
Removable.destroy
```
***
### execute()
```ts
execute(variables): Promise<TData>;
```
Defined in: [packages/query-core/src/mutation.ts:284](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L284)
Runs the mutation function for the given variables through a retryer, and
drives the mutation's state and lifecycle callbacks through to settlement.
If this mutation's state is already `pending` when `execute` is called
(i.e. it was restored, still in-flight, from a dehydrated state), the
`onMutate` step is skipped and a `continue` action is dispatched to
unpause it; otherwise a `pending` action is dispatched first, then the
mutation cache's `onMutate` and the mutation's own `onMutate` option are
awaited in that order, and the resulting context is stored.
The mutation function is then run (subject to `retry`/`retryDelay`/
`networkMode`, and to the mutation cache's scope-based serialization).
On success, the cache's `onSuccess`/`onSettled` callbacks run before the
mutation's own `onSuccess`/`onSettled` options, a `success` action is
dispatched, and the resolved data is returned. On failure, the same
cache-then-option ordering is used for `onError`/`onSettled`, but each of
those four callbacks is individually caught so that a throwing callback
cannot mask the original error; an `error` action is then dispatched and
the original error is re-thrown.
#### Parameters
##### variables
`TVariables`
#### Returns
`Promise`\<`TData`\>
#### Example
```ts
// Called internally by `MutationObserver.mutate` and `Mutation.continue` —
// applications normally trigger mutations through those, not this method.
const data = await mutation.execute(variables)
```
#### See
[Mutation#continue](#continue)
***
### optionalRemove()
```ts
protected optionalRemove(): void;
```
Defined in: [packages/query-core/src/mutation.ts:212](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L212)
#### Returns
`void`
#### Overrides
```ts
Removable.optionalRemove
```
***
### scheduleGc()
```ts
protected scheduleGc(): void;
```
Defined in: [packages/query-core/src/removable.ts:14](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L14)
#### Returns
`void`
#### Inherited from
```ts
Removable.scheduleGc
```
***
### updateGcTime()
```ts
protected updateGcTime(newGcTime): void;
```
Defined in: [packages/query-core/src/removable.ts:24](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L24)
#### Parameters
##### newGcTime
`number` | `undefined`
#### Returns
`void`
#### Inherited from
```ts
Removable.updateGcTime
```

316
docs/framework/svelte/reference/classes/MutationCache.md Normal file
View File

@@ -0,0 +1,316 @@
---
id: MutationCache
title: MutationCache
---
Defined in: [packages/query-core/src/mutationCache.ts:124](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L124)
The `MutationCache` is the storage for mutations.
Normally, you will not interact with the `MutationCache` directly and instead use a
`QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of
safe/known updates to the cache, such as mutations being added, removed, or updated.
## Example
```ts
const unsubscribe = mutationCache.subscribe((event) => {
console.log(event.type, event.mutation)
})
```
## Extends
- `Subscribable`\<`MutationCacheListener`\>
## Constructors
### Constructor
```ts
new MutationCache(config): MutationCache;
```
Defined in: [packages/query-core/src/mutationCache.ts:129](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L129)
#### Parameters
##### config
[`MutationCacheConfig`](../interfaces/MutationCacheConfig.md) = `{}`
#### Returns
`MutationCache`
#### Overrides
```ts
Subscribable<MutationCacheListener>.constructor
```
## Properties
### config
```ts
config: MutationCacheConfig = {};
```
Defined in: [packages/query-core/src/mutationCache.ts:129](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L129)
***
### listeners
```ts
protected listeners: Set<MutationCacheListener>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
## Methods
### clear()
```ts
clear(): void;
```
Defined in: [packages/query-core/src/mutationCache.ts:236](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L236)
Removes all mutations from the cache.
#### Returns
`void`
#### Example
```ts
const mutationCache = queryClient.getMutationCache()
mutationCache.clear()
```
***
### find()
```ts
find<TData, TError, TVariables, TOnMutateResult>(filters):
| Mutation<TData, TError, TVariables, TOnMutateResult>
| undefined;
```
Defined in: [packages/query-core/src/mutationCache.ts:278](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L278)
A slightly more advanced method that can be used to get an existing mutation instance from
the cache. If the mutation does not exist, `undefined` is returned.
This is not typically needed for most applications, but can come in handy when needing more
information about a mutation in rare scenarios.
#### Type Parameters
##### TData
`TData` = `unknown`
##### TError
`TError` = `Error`
##### TVariables
`TVariables` = `any`
##### TOnMutateResult
`TOnMutateResult` = `unknown`
#### Parameters
##### filters
[`MutationFilters`](../interfaces/MutationFilters.md)
#### Returns
\| [`Mutation`](Mutation.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
\| `undefined`
#### See
[MutationCache#findAll](#findall)
#### Example
```ts
const mutationCache = queryClient.getMutationCache()
const mutation = mutationCache.find({ mutationKey: ['addPost'] })
```
***
### findAll()
```ts
findAll(filters): Mutation<unknown, Error, unknown, unknown>[];
```
Defined in: [packages/query-core/src/mutationCache.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L308)
An even more advanced method that can be used to get existing mutation instances from the
cache that match the given filters. If no mutations match, an empty array is returned.
This is not typically needed for most applications, but can come in handy when needing more
information about mutations in rare scenarios.
#### Parameters
##### filters
[`MutationFilters`](../interfaces/MutationFilters.md) = `{}`
#### Returns
[`Mutation`](Mutation.md)\<`unknown`, `Error`, `unknown`, `unknown`\>[]
#### See
[MutationCache#find](#find)
#### Example
```ts
const mutationCache = queryClient.getMutationCache()
const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })
```
***
### getAll()
```ts
getAll(): Mutation<unknown, Error, unknown, unknown>[];
```
Defined in: [packages/query-core/src/mutationCache.ts:259](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L259)
Returns all mutations within the cache.
This is not typically needed for most applications, but can come in handy when needing more
information about a mutation in rare scenarios.
#### Returns
[`Mutation`](Mutation.md)\<`unknown`, `Error`, `unknown`, `unknown`\>[]
#### Example
```ts
const mutationCache = queryClient.getMutationCache()
const mutations = mutationCache.getAll()
```
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/subscribable.ts:23](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L23)
#### Returns
`void`
#### Inherited from
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/subscribable.ts:27](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L27)
#### Returns
`void`
#### Inherited from
```ts
Subscribable.onUnsubscribe
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`MutationCacheListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

335
docs/framework/svelte/reference/classes/MutationObserver.md Normal file
View File

@@ -0,0 +1,335 @@
---
id: MutationObserver
title: MutationObserver
---
Defined in: [packages/query-core/src/mutationObserver.ts:38](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L38)
Observes a single mutation and derives a `MutationObserverResult` from it.
A framework hook like `useMutation` creates one `MutationObserver` per hook
call, keeps it stable across re-renders, calls `setOptions` when the options
passed to the hook change, subscribes to it to re-render on updates, and
reads `getCurrentResult()` for the value to return. Calling `mutate()`
builds a new underlying `Mutation` in the `MutationCache` and executes it.
## Example
```ts
const observer = new MutationObserver(queryClient, {
mutationFn: (variables: { title: string }) => addPost(variables),
})
```
## Extends
- `Subscribable`\<`MutationObserverListener`\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Constructors
### Constructor
```ts
new MutationObserver<TData, TError, TVariables, TOnMutateResult>(client, options): MutationObserver<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutationObserver.ts:58](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L58)
#### Parameters
##### client
[`QueryClient`](QueryClient.md)
##### options
[`MutationObserverOptions`](../interfaces/MutationObserverOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Returns
`MutationObserver`\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Overrides
```ts
Subscribable<
MutationObserverListener<TData, TError, TVariables, TOnMutateResult>
>.constructor
```
## Properties
### listeners
```ts
protected listeners: Set<MutationObserverListener<TData, TError, TVariables, TOnMutateResult>>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
***
### options
```ts
options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutationObserver.ts:46](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L46)
## Methods
### bindMethods()
```ts
protected bindMethods(): void;
```
Defined in: [packages/query-core/src/mutationObserver.ts:75](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L75)
#### Returns
`void`
***
### getCurrentResult()
```ts
getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/mutationObserver.ts:155](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L155)
Returns the observer's current result, derived from the observed
mutation's state (or the default, `idle` state if no mutation has been
built yet, e.g. before the first `mutate()` call or after `reset()`).
#### Returns
[`MutationObserverResult`](../type-aliases/MutationObserverResult.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### mutate()
```ts
mutate(variables, options?): Promise<TData>;
```
Defined in: [packages/query-core/src/mutationObserver.ts:207](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L207)
Builds a new `Mutation` in the `MutationCache` using the observer's
current options, detaches this observer from any previously observed
mutation, attaches it to the new one, and executes it with the given
variables.
The optional per-call `options` (`onSuccess`/`onError`/`onSettled`) are
invoked once the mutation settles, in addition to any callbacks defined
on the observer's own options.
#### Parameters
##### variables
`TVariables`
##### options?
[`MutateOptions`](../interfaces/MutateOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Returns
`Promise`\<`TData`\>
#### Example
```ts
await observer.mutate(
{ title: 'New post' },
{ onSuccess: (data) => console.log(data) },
)
```
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/mutationObserver.ts:127](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L127)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/mutationObserver.ts:135](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L135)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onUnsubscribe
```
***
### reset()
```ts
reset(): void;
```
Defined in: [packages/query-core/src/mutationObserver.ts:180](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L180)
Detaches the observer from the mutation it is currently observing (if
any) and resets the observed result back to its default, `idle` state.
This does not cancel an in-flight mutation; the mutation itself keeps
running to completion and its own callbacks still fire, but this
observer stops reflecting its state and a subsequent `mutate()` call
will build a brand new mutation.
#### Returns
`void`
#### Example
```ts
observer.reset()
```
#### See
[MutationObserver#mutate](#mutate)
***
### setOptions()
```ts
setOptions(options): void;
```
Defined in: [packages/query-core/src/mutationObserver.ts:96](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationObserver.ts#L96)
Updates the observer's options.
If the new `mutationKey` differs from the previous one (and both were
defined), the observer is reset, detaching it from the mutation it was
observing. Otherwise, if the currently observed mutation is still
`pending`, its options are updated in place as well.
#### Parameters
##### options
[`MutationObserverOptions`](../interfaces/MutationObserverOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Returns
`void`
#### Example
```ts
observer.setOptions({
mutationFn: (variables: { title: string }) => addPost(variables),
onSuccess: (data) => console.log(data),
})
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`MutationObserverListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

325
docs/framework/svelte/reference/classes/QueriesObserver.md Normal file
View File

@@ -0,0 +1,325 @@
---
id: QueriesObserver
title: QueriesObserver
---
Defined in: [packages/query-core/src/queriesObserver.ts:56](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L56)
A `QueriesObserver` watches an array of queries at once, exposing them as
a single array of `QueryObserverResult`s (or, when a `combine` option is
given, as a combined value derived from that array). It manages one
internal `QueryObserver` per query, and is the primitive that framework
adapters (e.g. `useQueries`) build their hooks on top of.
## Example
```ts
const observer = new QueriesObserver(queryClient, [
{ queryKey: ['post', 1], queryFn: fetchPost },
{ queryKey: ['post', 2], queryFn: fetchPost },
])
const unsubscribe = observer.subscribe((result) => {
console.log(result)
})
```
## Extends
- `Subscribable`\<`QueriesObserverListener`\>
## Type Parameters
### TCombinedResult
`TCombinedResult` = [`QueryObserverResult`](../type-aliases/QueryObserverResult.md)[]
## Constructors
### Constructor
```ts
new QueriesObserver<TCombinedResult>(
client,
queries,
options?): QueriesObserver<TCombinedResult>;
```
Defined in: [packages/query-core/src/queriesObserver.ts:70](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L70)
#### Parameters
##### client
[`QueryClient`](QueryClient.md)
##### queries
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`any`, `any`, `any`, `any`, `any`, `never`\>[]
##### options?
[`QueriesObserverOptions`](../interfaces/QueriesObserverOptions.md)\<`TCombinedResult`\>
#### Returns
`QueriesObserver`\<`TCombinedResult`\>
#### Overrides
```ts
Subscribable<QueriesObserverListener>.constructor
```
## Properties
### listeners
```ts
protected listeners: Set<QueriesObserverListener>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
## Methods
### destroy()
```ts
destroy(): void;
```
Defined in: [packages/query-core/src/queriesObserver.ts:106](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L106)
Stops observing all queries: clears all listeners and destroys every
underlying `QueryObserver` this observer manages.
#### Returns
`void`
***
### getCurrentResult()
```ts
getCurrentResult(): QueryObserverResult[];
```
Defined in: [packages/query-core/src/queriesObserver.ts:210](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L210)
Returns the most recently computed array of `QueryObserverResult`s, one
per observed query, in the same order as the queries passed to the
constructor or `setQueries`.
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)[]
#### Example
```ts
const results = observer.getCurrentResult()
const data = results.map((result) => result.data)
```
***
### getObservers()
```ts
getObservers(): QueryObserver<unknown, Error, unknown, unknown, readonly unknown[]>[];
```
Defined in: [packages/query-core/src/queriesObserver.ts:227](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L227)
Returns the underlying `QueryObserver` instances this observer manages,
in the same order as the queries passed to the constructor or
`setQueries`.
#### Returns
[`QueryObserver`](QueryObserver.md)\<`unknown`, `Error`, `unknown`, `unknown`, readonly `unknown`[]\>[]
***
### getOptimisticResult()
```ts
getOptimisticResult(queries, combine): [QueryObserverResult[], (r?) => TCombinedResult, () => QueryObserverResult[]];
```
Defined in: [packages/query-core/src/queriesObserver.ts:238](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L238)
The `QueriesObserver` counterpart of [QueryObserver#getOptimisticResult](QueryObserver.md#getoptimisticresult) — computes
the result for the given (already-defaulted) queries right now, synchronously. Called by
framework adapters (e.g. `useQueries`) ahead of subscribing, returning a tuple of the raw
per-query results, a function to compute the combined result from them, and a function to
wrap the results for property-access tracking.
#### Parameters
##### queries
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`unknown`, `Error`, `unknown`, `unknown`, readonly `unknown`[], `never`\>[]
##### combine
`CombineFn`\<`TCombinedResult`\> | `undefined`
#### Returns
\[[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)[], (`r?`) => `TCombinedResult`, () => [`QueryObserverResult`](../type-aliases/QueryObserverResult.md)[]\]
***
### getQueries()
```ts
getQueries(): Query<unknown, Error, unknown, readonly unknown[]>[];
```
Defined in: [packages/query-core/src/queriesObserver.ts:218](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L218)
Returns the underlying `Query` instances currently being observed, in
the same order as the queries passed to the constructor or `setQueries`.
#### Returns
[`Query`](Query.md)\<`unknown`, `Error`, `unknown`, readonly `unknown`[]\>[]
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/queriesObserver.ts:86](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L86)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/queriesObserver.ts:96](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L96)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onUnsubscribe
```
***
### setQueries()
```ts
setQueries(queries, options?): void;
```
Defined in: [packages/query-core/src/queriesObserver.ts:127](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L127)
Replaces the set of queries being observed. Existing `QueryObserver`s
are reused for queries that match an already-observed query hash;
observers for queries that are no longer present are destroyed, and new
observers are created and subscribed to for newly added queries.
#### Parameters
##### queries
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`unknown`, `Error`, `unknown`, `unknown`, readonly `unknown`[], `never`\>[]
##### options?
[`QueriesObserverOptions`](../interfaces/QueriesObserverOptions.md)\<`TCombinedResult`\>
#### Returns
`void`
#### Example
```ts
observer.setQueries([
{ queryKey: ['post', 1], queryFn: fetchPost },
{ queryKey: ['post', 3], queryFn: fetchPost },
])
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`QueriesObserverListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

585
docs/framework/svelte/reference/classes/Query.md Normal file
View File

@@ -0,0 +1,585 @@
---
id: Query
title: Query
---
Defined in: [packages/query-core/src/query.ts:225](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L225)
Represents a single cached query. A `Query` holds the query's key, options,
state (data/error/status), and the observers currently subscribed to it.
Instances are created and managed internally by `QueryCache`; application
code typically interacts with queries indirectly through `QueryClient` or
a framework hook like `useQuery`. Direct access to a `Query` instance is
possible via `queryCache.find()`/`findAll()` for inspecting cache state.
## Example
```ts
const queryCache = queryClient.getQueryCache()
const query = queryCache.find({ queryKey: ['posts'] })
if (query) {
console.log(query.state.dataUpdatedAt)
}
```
## Extends
- `Removable`
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
## Constructors
### Constructor
```ts
new Query<TQueryFnData, TError, TData, TQueryKey>(config): Query<TQueryFnData, TError, TData, TQueryKey>;
```
Defined in: [packages/query-core/src/query.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L246)
#### Parameters
##### config
`QueryConfig`\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
#### Returns
`Query`\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
#### Overrides
```ts
Removable.constructor
```
## Properties
### gcTime
```ts
gcTime: number;
```
Defined in: [packages/query-core/src/removable.ts:7](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L7)
#### Inherited from
```ts
Removable.gcTime
```
***
### observers
```ts
observers: QueryObserver<any, any, any, any, any>[];
```
Defined in: [packages/query-core/src/query.ts:242](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L242)
***
### options
```ts
options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
```
Defined in: [packages/query-core/src/query.ts:233](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L233)
***
### queryHash
```ts
queryHash: string;
```
Defined in: [packages/query-core/src/query.ts:232](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L232)
***
### queryKey
```ts
queryKey: TQueryKey;
```
Defined in: [packages/query-core/src/query.ts:231](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L231)
***
### state
```ts
state: QueryState<TData, TError>;
```
Defined in: [packages/query-core/src/query.ts:234](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L234)
## Accessors
### meta
#### Get Signature
```ts
get meta(): Record<string, unknown> | undefined;
```
Defined in: [packages/query-core/src/query.ts:264](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L264)
The `meta` object passed in the query's options, if any.
##### Returns
`Record`\<`string`, `unknown`\> \| `undefined`
***
### promise
#### Get Signature
```ts
get promise(): Promise<TData> | undefined;
```
Defined in: [packages/query-core/src/query.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L277)
The promise for the currently in-flight fetch, if the query is fetching.
`undefined` when the query is not fetching.
##### Returns
`Promise`\<`TData`\> \| `undefined`
## Methods
### cancel()
```ts
cancel(options?): Promise<void>;
```
Defined in: [packages/query-core/src/query.ts:348](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L348)
Cancels the query's currently in-flight fetch, if any.
- Returns a promise that resolves once the cancellation has settled.
- If no fetch is in progress, resolves immediately.
#### Parameters
##### options?
[`CancelOptions`](../interfaces/CancelOptions.md)
#### Returns
`Promise`\<`void`\>
#### Example
```ts
await query.cancel()
```
***
### clearGcTimeout()
```ts
protected clearGcTimeout(): void;
```
Defined in: [packages/query-core/src/removable.ts:32](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L32)
#### Returns
`void`
#### Inherited from
```ts
Removable.clearGcTimeout
```
***
### destroy()
```ts
destroy(): void;
```
Defined in: [packages/query-core/src/query.ts:361](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L361)
Clears the query's garbage collection timeout and silently cancels any
in-flight fetch. Called by `QueryCache` when the query is removed from
the cache.
#### Returns
`void`
#### See
[Query#cancel](#cancel)
#### Overrides
```ts
Removable.destroy
```
***
### fetch()
```ts
fetch(options?, fetchOptions?): Promise<TData>;
```
Defined in: [packages/query-core/src/query.ts:590](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L590)
Fetches the query, i.e. runs its `queryFn` (through any configured
retryer/behavior) and updates the query's state with the result.
- If a fetch is already in flight, returns its promise instead of
starting a new one, unless `fetchOptions.cancelRefetch` is set and the
query already has data, in which case the current fetch is silently
cancelled first.
- If `options` is passed, it replaces the query's current options
before fetching.
#### Parameters
##### options?
[`QueryOptions`](../interfaces/QueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `never`\>
##### fetchOptions?
`FetchOptions`\<`TQueryFnData`\>
#### Returns
`Promise`\<`TData`\>
***
### getObserversCount()
```ts
getObserversCount(): number;
```
Defined in: [packages/query-core/src/query.ts:560](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L560)
Returns the number of observers currently subscribed to this query.
#### Returns
`number`
#### Example
```ts
if (query.getObserversCount() === 0) {
// no component is currently watching this query
}
```
***
### invalidate()
```ts
invalidate(): void;
```
Defined in: [packages/query-core/src/query.ts:574](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L574)
Marks the query as invalidated, unless it is already invalidated. This
updates `state.isInvalidated` and notifies observers, but does not by
itself trigger a refetch.
#### Returns
`void`
#### Example
```ts
query.invalidate()
```
***
### isActive()
```ts
isActive(): boolean;
```
Defined in: [packages/query-core/src/query.ts:386](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L386)
Returns `true` if the query has at least one observer for which `enabled`
does not resolve to `false`.
#### Returns
`boolean`
***
### isDisabled()
```ts
isDisabled(): boolean;
```
Defined in: [packages/query-core/src/query.ts:400](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L400)
Returns `true` if the query is disabled, meaning it will not fetch
automatically.
- If the query has observers, it is disabled when none of them are active
(see `isActive`).
- If the query has no observers, it is disabled when its `queryFn` is
`skipToken` or it has never been fetched.
#### Returns
`boolean`
***
### isFetched()
```ts
isFetched(): boolean;
```
Defined in: [packages/query-core/src/query.ts:412](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L412)
Returns `true` if the query has been fetched, i.e. it has resolved with
either data or an error at least once.
#### Returns
`boolean`
***
### isStale()
```ts
isStale(): boolean;
```
Defined in: [packages/query-core/src/query.ts:447](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L447)
Returns `true` if the query is stale.
- If the query has observers, defers to whether any observer's current
result reports `isStale` (which accounts for each observer's own
`staleTime` and `enabled` state).
- If the query has no observers, it is considered stale when it has no
data or has been invalidated.
#### Returns
`boolean`
#### See
[Query#isStaleByTime](#isstalebytime)
#### Example
```ts
if (query.isStale()) {
// refetch or otherwise treat the cached data as outdated
}
```
***
### isStaleByTime()
```ts
isStaleByTime(staleTime): boolean;
```
Defined in: [packages/query-core/src/query.ts:473](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L473)
Returns `true` if the query's data is stale relative to the given
`staleTime` (defaults to `0`).
- A query with no data is always stale.
- `staleTime: 'static'` is never stale.
- An invalidated query is always stale.
- Otherwise, staleness is based on elapsed time since `dataUpdatedAt`.
#### Parameters
##### staleTime
[`StaleTime`](../type-aliases/StaleTime.md) = `0`
#### Returns
`boolean`
#### See
[Query#isStale](#isstale)
#### Example
```ts
const isStale = query.isStaleByTime(1000 * 60)
```
***
### isStatic()
```ts
isStatic(): boolean;
```
Defined in: [packages/query-core/src/query.ts:420](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L420)
Returns `true` if the query has at least one observer configured with
`staleTime: 'static'`, meaning it is treated as never stale.
#### Returns
`boolean`
***
### optionalRemove()
```ts
protected optionalRemove(): void;
```
Defined in: [packages/query-core/src/query.ts:305](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L305)
#### Returns
`void`
#### Overrides
```ts
Removable.optionalRemove
```
***
### reset()
```ts
reset(): void;
```
Defined in: [packages/query-core/src/query.ts:377](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L377)
Resets the query back to its initial state (the state it had when it was
first created, e.g. any `initialData`), destroying it first to cancel any
in-flight fetch.
#### Returns
`void`
***
### scheduleGc()
```ts
protected scheduleGc(): void;
```
Defined in: [packages/query-core/src/removable.ts:14](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L14)
#### Returns
`void`
#### Inherited from
```ts
Removable.scheduleGc
```
***
### setState()
```ts
setState(state): void;
```
Defined in: [packages/query-core/src/query.ts:334](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L334)
Merges the given partial state directly into this query's state, notifying observers. Used
by persistence and broadcast plugins to restore a state snapshot, and by devtools to let a
user manually trigger a loading/error state or edit the cached data.
#### Parameters
##### state
`Partial`\<[`QueryState`](../interfaces/QueryState.md)\<`TData`, `TError`\>\>
#### Returns
`void`
***
### updateGcTime()
```ts
protected updateGcTime(newGcTime): void;
```
Defined in: [packages/query-core/src/removable.ts:24](https://github.com/TanStack/query/blob/main/packages/query-core/src/removable.ts#L24)
#### Parameters
##### newGcTime
`number` | `undefined`
#### Returns
`void`
#### Inherited from
```ts
Removable.updateGcTime
```

471
docs/framework/svelte/reference/classes/QueryCache.md Normal file
View File

@@ -0,0 +1,471 @@
---
id: QueryCache
title: QueryCache
---
Defined in: [packages/query-core/src/queryCache.ts:123](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L123)
The `QueryCache` is the storage mechanism for TanStack Query. It stores all the data, meta
information, and state of the queries it contains.
Normally, you will not interact with the `QueryCache` directly and instead use a `QueryClient`
for a specific cache. You can subscribe to it (inherited from `Subscribable`) to be informed of
safe/known updates to the cache, such as queries being added, removed, or updated — updates made
outside of the cache's own tracked mechanisms (e.g. mutating a query's state object directly) do
not notify subscribers.
## Example
```ts
const unsubscribe = queryCache.subscribe((event) => {
console.log(event.type, event.query)
})
```
## Extends
- `Subscribable`\<`QueryCacheListener`\>
## Constructors
### Constructor
```ts
new QueryCache(config): QueryCache;
```
Defined in: [packages/query-core/src/queryCache.ts:126](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L126)
#### Parameters
##### config
[`QueryCacheConfig`](../interfaces/QueryCacheConfig.md) = `{}`
#### Returns
`QueryCache`
#### Overrides
```ts
Subscribable<QueryCacheListener>.constructor
```
## Properties
### config
```ts
config: QueryCacheConfig = {};
```
Defined in: [packages/query-core/src/queryCache.ts:126](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L126)
***
### listeners
```ts
protected listeners: Set<QueryCacheListener>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
## Methods
### build()
```ts
build<TQueryFnData, TError, TData, TQueryKey>(
client,
options,
state?): Query<TQueryFnData, TError, TData, TQueryKey>;
```
Defined in: [packages/query-core/src/queryCache.ts:147](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L147)
Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or
builds and adds a new one to the cache if none exists yet. Used by framework adapters and
plugins (e.g. broadcast/persistence) that need to get-or-create a `Query` directly, bypassing
the reactive `QueryObserver` machinery.
#### Type Parameters
##### TQueryFnData
`TQueryFnData` = `unknown`
##### TError
`TError` = `Error`
##### TData
`TData` = `TQueryFnData`
##### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### Parameters
##### client
[`QueryClient`](QueryClient.md)
##### options
[`WithRequired`](../type-aliases/WithRequired.md)\<[`QueryOptions`](../interfaces/QueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `never`\>, `"queryKey"`\>
##### state?
[`QueryState`](../interfaces/QueryState.md)\<`TData`, `TError`\>
#### Returns
[`Query`](Query.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const query = queryCache.build(queryClient, {
queryKey: ['posts'],
queryFn: fetchPosts,
})
```
***
### clear()
```ts
clear(): void;
```
Defined in: [packages/query-core/src/queryCache.ts:232](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L232)
Removes all queries from the cache.
#### Returns
`void`
#### Example
```ts
const queryCache = queryClient.getQueryCache()
queryCache.clear()
```
***
### find()
```ts
find<TQueryFnData, TError, TData>(filters):
| Query<TQueryFnData, TError, TData, readonly unknown[]>
| undefined;
```
Defined in: [packages/query-core/src/queryCache.ts:299](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L299)
A slightly more advanced method that can be used to get an existing query instance from the
cache. This instance not only contains all the state for the query, but all of the instances,
and underlying guts of the query as well. If the query does not exist, `undefined` is
returned.
This is not typically needed for most applications, but can come in handy when needing more
information about a query in rare scenarios (e.g. looking at `query.state.dataUpdatedAt` to
decide whether a query is fresh enough to be used as an initial value).
#### Type Parameters
##### TQueryFnData
`TQueryFnData` = `unknown`
##### TError
`TError` = `Error`
##### TData
`TData` = `TQueryFnData`
#### Parameters
##### filters
[`WithRequired`](../type-aliases/WithRequired.md)\<[`QueryFilters`](../interfaces/QueryFilters.md)\<readonly `unknown`[]\>, `"queryKey"`\>
#### Returns
\| [`Query`](Query.md)\<`TQueryFnData`, `TError`, `TData`, readonly `unknown`[]\>
\| `undefined`
#### See
[QueryCache#findAll](#findall)
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const query = queryCache.find({ queryKey: ['posts'] })
```
***
### findAll()
```ts
findAll(filters): Query<unknown, Error, unknown, readonly unknown[]>[];
```
Defined in: [packages/query-core/src/queryCache.ts:324](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L324)
An even more advanced method that can be used to get existing query instances from the cache
that partially match a query key. If no queries match, an empty array is returned.
This is not typically needed for most applications, but can come in handy when needing more
information about queries in rare scenarios.
#### Parameters
##### filters
[`QueryFilters`](../interfaces/QueryFilters.md)\<`any`\> = `{}`
#### Returns
[`Query`](Query.md)\<`unknown`, `Error`, `unknown`, readonly `unknown`[]\>[]
#### See
[QueryCache#find](#find)
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const queries = queryCache.findAll({ queryKey: ['posts'] })
```
***
### get()
```ts
get<TQueryFnData, TError, TData, TQueryKey>(queryHash):
| Query<TQueryFnData, TError, TData, TQueryKey>
| undefined;
```
Defined in: [packages/query-core/src/queryCache.ts:254](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L254)
Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none
exists. Unlike [QueryCache#find](#find), this looks up by the already-computed hash rather
than by `QueryFilters`. Used by plugins (e.g. broadcast/hydration) that already have a hash
to look up directly.
#### Type Parameters
##### TQueryFnData
`TQueryFnData` = `unknown`
##### TError
`TError` = `Error`
##### TData
`TData` = `TQueryFnData`
##### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### Parameters
##### queryHash
`string`
#### Returns
\| [`Query`](Query.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
\| `undefined`
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const queryHash = hashKey(['posts'])
const query = queryCache.get(queryHash)
```
***
### getAll()
```ts
getAll(): Query<unknown, Error, unknown, readonly unknown[]>[];
```
Defined in: [packages/query-core/src/queryCache.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L277)
Returns all queries within the cache.
#### Returns
[`Query`](Query.md)\<`unknown`, `Error`, `unknown`, readonly `unknown`[]\>[]
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const queries = queryCache.getAll()
```
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/subscribable.ts:23](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L23)
#### Returns
`void`
#### Inherited from
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/subscribable.ts:27](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L27)
#### Returns
`void`
#### Inherited from
```ts
Subscribable.onUnsubscribe
```
***
### remove()
```ts
remove(query): void;
```
Defined in: [packages/query-core/src/queryCache.ts:208](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L208)
Destroys the given `Query` and removes it from the cache, notifying subscribers with a
`'removed'` event. A no-op if the query is no longer the one currently stored under its hash
(e.g. it was already replaced). Used by plugins (e.g. the broadcast client) that mirror
removals across `QueryCache` instances.
#### Parameters
##### query
[`Query`](Query.md)\<`any`, `any`, `any`, `any`\>
#### Returns
`void`
#### Example
```ts
const queryCache = queryClient.getQueryCache()
const query = queryCache.find({ queryKey: ['posts'] })
if (query) {
queryCache.remove(query)
}
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`QueryCacheListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

1466
docs/framework/svelte/reference/classes/QueryClient.md Normal file
View File

File diff suppressed because it is too large Load Diff

555
docs/framework/svelte/reference/classes/QueryObserver.md Normal file
View File

@@ -0,0 +1,555 @@
---
id: QueryObserver
title: QueryObserver
---
Defined in: [packages/query-core/src/queryObserver.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L57)
A `QueryObserver` watches a single query in the `QueryCache` and computes a
`QueryObserverResult` from its state, recomputing and notifying subscribers
whenever the underlying query (or the observer's options) changes. It is
the primitive that framework adapters (e.g. `useQuery`) build their hooks
on top of, but it can also be used directly to observe and switch between
queries outside of any framework.
## Example
```ts
const observer = new QueryObserver(queryClient, {
queryKey: ['posts'],
queryFn: fetchPosts,
})
const unsubscribe = observer.subscribe((result) => {
console.log(result.data)
})
```
## Extends
- `Subscribable`\<`QueryObserverListener`\<`TData`, `TError`\>\>
## Extended by
- [`InfiniteQueryObserver`](InfiniteQueryObserver.md)
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryData
`TQueryData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
## Constructors
### Constructor
```ts
new QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>(client, options): QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/queryObserver.ts:87](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L87)
#### Parameters
##### client
[`QueryClient`](QueryClient.md)
##### options
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Returns
`QueryObserver`\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Overrides
```ts
Subscribable<QueryObserverListener<TData, TError>>.constructor
```
## Properties
### listeners
```ts
protected listeners: Set<QueryObserverListener<TData, TError>>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
***
### options
```ts
options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/queryObserver.ts:89](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L89)
## Methods
### bindMethods()
```ts
protected bindMethods(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:106](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L106)
#### Returns
`void`
***
### createResult()
```ts
protected createResult(query, options): QueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/queryObserver.ts:559](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L559)
#### Parameters
##### query
[`Query`](Query.md)\<`TQueryFnData`, `TError`, `TQueryData`, `TQueryKey`\>
##### options
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
***
### destroy()
```ts
destroy(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:161](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L161)
Stops observing the current query: clears all listeners, cancels the
stale and refetch-interval timers, and removes this observer from the
query it was observing.
#### Returns
`void`
***
### fetch()
```ts
protected fetch(fetchOptions): Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/queryObserver.ts:448](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L448)
#### Parameters
##### fetchOptions
`ObserverFetchOptions`
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
***
### fetchOptimistic()
```ts
fetchOptimistic(options): Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/queryObserver.ts:395](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L395)
Fetches a query defined by the given options without affecting this
observer's own tracked query or result, and returns a promise that
resolves with the `QueryObserverResult` for that fetch. This is useful
for prefetching data that another observer (e.g. a query about to be
navigated to) will need, ahead of time.
#### Parameters
##### options
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const result = await observer.fetchOptimistic({
queryKey: ['posts', 2],
queryFn: () => fetchPost(2),
})
console.log(result.data)
```
***
### getCurrentQuery()
```ts
getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/queryObserver.ts:357](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L357)
Returns the `Query` instance this observer is currently observing.
#### Returns
[`Query`](Query.md)\<`TQueryFnData`, `TError`, `TQueryData`, `TQueryKey`\>
***
### getCurrentResult()
```ts
getCurrentResult(): QueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/queryObserver.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L321)
Returns the most recently computed `QueryObserverResult` for the
observed query. This is a point-in-time read; to be notified of updates
as they happen, subscribe to the observer instead (its inherited
`subscribe` method).
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
#### Example
```ts
const result = observer.getCurrentResult()
console.log(result.status, result.data)
```
***
### getOptimisticResult()
```ts
getOptimisticResult(options): QueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/queryObserver.ts:272](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L272)
Computes the result the observer would produce for the given (already-defaulted) options
right now, building the underlying `Query` if it doesn't exist yet, without waiting for a
subscription callback. Called by framework adapters on every render (e.g. `useQuery`) so the
returned value is available synchronously, ahead of `setOptions` triggering an actual fetch.
#### Parameters
##### options
[`DefaultedQueryObserverOptions`](../type-aliases/DefaultedQueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
***
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:110](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L110)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:124](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L124)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onUnsubscribe
```
***
### refetch()
```ts
refetch(__namedParameters): Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/queryObserver.ts:371](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L371)
Refetches the observed query and returns a promise that resolves with
the resulting `QueryObserverResult`.
#### Parameters
##### \_\_namedParameters
[`RefetchOptions`](../interfaces/RefetchOptions.md) = `{}`
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Example
```ts
const result = await observer.refetch({ cancelRefetch: false })
console.log(result.data)
```
***
### setOptions()
```ts
setOptions(options): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:182](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L182)
Updates the observer's options. This will re-resolve the query being
observed (switching to a different query if the `queryKey` changed),
trigger a fetch if the new options require one and the observer has
subscribers, recompute the current result, and reschedule the stale and
refetch-interval timers as needed.
#### Parameters
##### options
[`QueryObserverOptions`](../interfaces/QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryData`, `TQueryKey`\>
#### Returns
`void`
#### Example
```ts
observer.setOptions({ queryKey: ['posts', 1], queryFn: () => fetchPost(1) })
// later: switch to a different query, reusing the same observer
observer.setOptions({ queryKey: ['posts', 2], queryFn: () => fetchPost(2) })
```
***
### shouldFetchOnReconnect()
```ts
shouldFetchOnReconnect(): boolean;
```
Defined in: [packages/query-core/src/queryObserver.ts:135](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L135)
Returns whether the observed query is currently stale and configured
(via the `refetchOnReconnect` option) to refetch when the network
reconnects.
#### Returns
`boolean`
***
### shouldFetchOnWindowFocus()
```ts
shouldFetchOnWindowFocus(): boolean;
```
Defined in: [packages/query-core/src/queryObserver.ts:148](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L148)
Returns whether the observed query is currently stale and configured
(via the `refetchOnWindowFocus` option) to refetch when the window
regains focus.
#### Returns
`boolean`
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`QueryObserverListener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```
***
### trackProp()
```ts
trackProp(key): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:350](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L350)
Records that the given `QueryObserverResult` property was read, so a subsequent update only
notifies this observer if a tracked property actually changed. Normally called indirectly via
[QueryObserver#trackResult](#trackresult)'s proxy; exposed directly for adapters that track property
access themselves (e.g. through their own reactivity system) instead of via the proxy.
#### Parameters
##### key
`"error"` | `"data"` | `"isError"` | `"isPending"` | `"isLoading"` | `"isLoadingError"` | `"isRefetchError"` | `"isSuccess"` | `"isPlaceholderData"` | `"status"` | `"dataUpdatedAt"` | `"errorUpdatedAt"` | `"failureCount"` | `"failureReason"` | `"errorUpdateCount"` | `"isFetched"` | `"isFetchedAfterMount"` | `"isFetching"` | `"isInitialLoading"` | `"isPaused"` | `"isRefetching"` | `"isStale"` | `"isEnabled"` | `"refetch"` | `"fetchStatus"`
#### Returns
`void`
***
### trackResult()
```ts
trackResult(result, onPropTracked?): QueryObserverResult<TData, TError>;
```
Defined in: [packages/query-core/src/queryObserver.ts:331](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L331)
Wraps a `QueryObserverResult` in a `Proxy` that records which properties are read, via
[QueryObserver#trackProp](#trackprop) (and an optional `onPropTracked` callback). Used by framework
adapters when `notifyOnChangeProps` is not set, to implement its default "only re-render on
properties you actually read" behavior.
#### Parameters
##### result
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
##### onPropTracked?
(`key`) => `void`
#### Returns
[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>
***
### updateResult()
```ts
updateResult(): void;
```
Defined in: [packages/query-core/src/queryObserver.ts:735](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryObserver.ts#L735)
Recomputes and stores the current result from the current query/options, notifying listeners
if it changed. Framework adapters call this right after subscribing to make sure no query
update was missed in the gap between creating the observer and subscribing to it.
#### Returns
`void`

233
docs/framework/svelte/reference/functions/createInfiniteQuery.md Normal file
View File

@@ -0,0 +1,233 @@
---
id: createInfiniteQuery
title: createInfiniteQuery
---
## Call Signature
```ts
function createInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options, queryClient?): DefinedCreateInfiniteQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createInfiniteQuery.ts:21](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createInfiniteQuery.ts#L21)
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### TPageParam
`TPageParam` = `unknown`
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`DefinedInitialDataInfiniteOptions`](../type-aliases/DefinedInitialDataInfiniteOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>\>
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
### Returns
[`DefinedCreateInfiniteQueryResult`](../type-aliases/DefinedCreateInfiniteQueryResult.md)\<`TData`, `TError`\>
## Call Signature
```ts
function createInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options, queryClient?): CreateInfiniteQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createInfiniteQuery.ts:40](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createInfiniteQuery.ts#L40)
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### TPageParam
`TPageParam` = `unknown`
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`UndefinedInitialDataInfiniteOptions`](../type-aliases/UndefinedInitialDataInfiniteOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>\>
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
### Returns
[`CreateInfiniteQueryResult`](../type-aliases/CreateInfiniteQueryResult.md)\<`TData`, `TError`\>
## Call Signature
```ts
function createInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options, queryClient?): CreateInfiniteQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createInfiniteQuery.ts:152](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createInfiniteQuery.ts#L152)
### Type Parameters
#### TQueryFnData
`TQueryFnData`
#### TError
`TError` = `Error`
#### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### TPageParam
`TPageParam` = `unknown`
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`CreateInfiniteQueryOptions`](../type-aliases/CreateInfiniteQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>\>
The [CreateInfiniteQueryOptions](../type-aliases/CreateInfiniteQueryOptions.md) to use — everything you can pass to
`createInfiniteQuery`, wrapped in an [Accessor](../type-aliases/Accessor.md) so options can be reactive.
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
### Returns
[`CreateInfiniteQueryResult`](../type-aliases/CreateInfiniteQueryResult.md)\<`TData`, `TError`\>
The current query result, plus `fetchNextPage`/`fetchPreviousPage`/`hasNextPage`/`hasPreviousPage`
to page through the query.
### See
[infiniteQueryOptions](infiniteQueryOptions.md) to share these options between `createInfiniteQuery` and imperative APIs
like `queryClient.infiniteQuery`.
### Examples
Fetching the next page from a "Load More" button click:
```svelte
<script lang="ts">
import { createInfiniteQuery } from '@tanstack/svelte-query'
const query = createInfiniteQuery(() => ({
queryKey: ['projects'],
queryFn: ({ pageParam }) => fetchProjects(pageParam),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
}))
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<ul>
{#each query.data.pages as page}
{#each page.projects as project (project.id)}
<li>{project.name}</li>
{/each}
{/each}
</ul>
<button
onclick={() => query.fetchNextPage()}
disabled={!query.hasNextPage || query.isFetching}
>
{query.isFetchingNextPage
? 'Loading more...'
: query.hasNextPage
? 'Load More'
: 'Nothing more to load'}
</button>
{/if}
```
Fetching the next page automatically as the user scrolls, using an `IntersectionObserver` on a
sentinel element after the list:
```svelte
<script lang="ts">
import { createInfiniteQuery } from '@tanstack/svelte-query'
const query = createInfiniteQuery(() => ({
queryKey: ['projects'],
queryFn: ({ pageParam }) => fetchProjects(pageParam),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
}))
let sentinel: HTMLDivElement | undefined = $state()
$effect(() => {
if (sentinel == null || !query.hasNextPage || query.isFetching) return
const observer = new IntersectionObserver(([entry]) => {
if (entry?.isIntersecting) query.fetchNextPage()
})
observer.observe(sentinel)
return () => observer.disconnect()
})
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<ul>
{#each query.data.pages as page}
{#each page.projects as project (project.id)}
<li>{project.name}</li>
{/each}
{/each}
</ul>
<div bind:this={sentinel}></div>
{/if}
```

201
docs/framework/svelte/reference/functions/createMutation.md Normal file
View File

@@ -0,0 +1,201 @@
---
id: createMutation
title: createMutation
---
```ts
function createMutation<TData, TError, TVariables, TContext>(options, queryClient?): CreateMutationResult<TData, TError, TVariables, TContext>;
```
Defined in: [packages/svelte-query/src/createMutation.svelte.ts:171](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createMutation.svelte.ts#L171)
Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.
`createMutation` is the function for that.
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = `Error`
### TVariables
`TVariables` = `void`
### TContext
`TContext` = `unknown`
## Parameters
### options
[`Accessor`](../type-aliases/Accessor.md)\<[`CreateMutationOptions`](../type-aliases/CreateMutationOptions.md)\<`TData`, `TError`, `TVariables`, `TContext`\>\>
The [CreateMutationOptions](../type-aliases/CreateMutationOptions.md) to use, wrapped in an [Accessor](../type-aliases/Accessor.md) so options can be
reactive.
### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
## Returns
[`CreateMutationResult`](../type-aliases/CreateMutationResult.md)\<`TData`, `TError`, `TVariables`, `TContext`\>
`mutate`/`mutateAsync` also accept per-call `onSuccess`/`onError`/`onSettled` callbacks as a second
argument, useful for triggering call-site side effects (e.g. navigation) without coupling them to the shared
mutation definition. If you make multiple requests, `onSuccess` will fire only after the latest call you've
made.
## See
[mutationOptions](mutationOptions.md) to share these options across multiple `createMutation` call sites, or to look
the mutation up elsewhere via its `mutationKey` (e.g. with `useMutationState`).
## Examples
```svelte
<script lang="ts">
import { createMutation, useQueryClient } from '@tanstack/svelte-query'
const queryClient = useQueryClient()
const addMutation = createMutation(() => ({
mutationFn: addTodo,
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
}))
</script>
<button
onclick={() =>
addMutation.mutate('Item', {
onError: (error) => console.error('Failed to add item:', error),
})
}
>
Add
</button>
```
Rendering the mutation's own state, rather than just firing it off:
```svelte
<script lang="ts">
import { createMutation, useQueryClient } from '@tanstack/svelte-query'
const queryClient = useQueryClient()
const addMutation = createMutation(() => ({
mutationFn: addTodo,
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
}))
</script>
{#if addMutation.isPending}
Adding todo...
{:else}
{#if addMutation.isError}
<div>An error occurred: {addMutation.error.message}</div>
{/if}
<button onclick={() => addMutation.mutate('Item')}>Add</button>
{/if}
```
Optimistic update via `onMutate`, rolling back on `onError`:
```svelte
<script lang="ts">
import { createMutation, useQueryClient } from '@tanstack/svelte-query'
const queryClient = useQueryClient()
const addMutation = createMutation(() => ({
mutationFn: addTodo,
onMutate: async (newTodo: string) => {
await queryClient.cancelQueries({ queryKey: ['todos'] })
const previousTodos = queryClient.getQueryData<Array<string>>(['todos'])
queryClient.setQueryData<Array<string>>(['todos'], (old) => [
...(old ?? []),
newTodo,
])
// Passed to `onError` as `onMutateResult` if the mutation fails.
return { previousTodos }
},
onError: (_err, _newTodo, onMutateResult) => {
queryClient.setQueryData(['todos'], onMutateResult?.previousTodos)
},
onSettled: () => {
queryClient.invalidateQueries({ queryKey: ['todos'] })
},
}))
</script>
<button onclick={() => addMutation.mutate('Item')}>Add</button>
```
Callbacks passed per call to `mutate` only fire for the last call — `mutateAsync` gives you a
promise per call instead, so you can wait for all of them when they succeed:
```svelte
<script lang="ts">
import { createMutation, useQueryClient } from '@tanstack/svelte-query'
const queryClient = useQueryClient()
const addMutation = createMutation(() => ({
mutationFn: addTodo,
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
}))
async function handleAddAll(todos: Array<string>) {
try {
await Promise.all(todos.map((todo) => addMutation.mutateAsync(todo)))
} catch (error) {
console.error('Failed to add todos:', error)
}
}
</script>
<button onclick={() => handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])}>
Add all
</button>
```
If some of the mutations above can fail independently of the others, and you want to know which ones
did — rather than losing that information the moment the first one rejects — swap `Promise.all` for
`Promise.allSettled`:
```svelte
<script lang="ts">
import { createMutation, useQueryClient } from '@tanstack/svelte-query'
const queryClient = useQueryClient()
const addMutation = createMutation(() => ({
mutationFn: addTodo,
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
}))
async function handleAddAll(todos: Array<string>) {
const addResults = await Promise.allSettled(
todos.map((todo) => addMutation.mutateAsync(todo)),
)
addResults.forEach((addResult, index) => {
if (addResult.status === 'rejected') {
console.error(`Failed to add "${todos[index]}":`, addResult.reason)
}
})
}
</script>
<button onclick={() => handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])}>
Add all
</button>
```

110
docs/framework/svelte/reference/functions/createQueries.md Normal file
View File

@@ -0,0 +1,110 @@
---
id: createQueries
title: createQueries
---
```ts
function createQueries<T, TCombinedResult>(createQueriesOptions, queryClient?): TCombinedResult;
```
Defined in: [packages/svelte-query/src/createQueries.svelte.ts:260](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createQueries.svelte.ts#L260)
## Type Parameters
### T
`T` *extends* `any`[]
### TCombinedResult
`TCombinedResult` = `T` *extends* \[\] ? \[\] : `T` *extends* \[`Head`\] ? \[`GetCreateQueryResult`\<`Head`\>\] : `T` *extends* \[`Head`, `...Tails[]`\] ? \[`...Tails[]`\] *extends* \[\] ? \[\] : \[`...Tails[]`\] *extends* \[`Head`\] ? \[`GetCreateQueryResult`\<`Head`\>, `GetCreateQueryResult`\<`Head`\>\] : \[`...Tails[]`\] *extends* \[`Head`, `...Tails[]`\] ? \[`...Tails[]`\] *extends* \[\] ? \[\] : \[`...Tails[]`\] *extends* \[`Head`\] ? \[`GetCreateQueryResult`\<`Head`\>, `GetCreateQueryResult`\<`Head`\>, `GetCreateQueryResult`\<`Head`\>\] : \[`...Tails[]`\] *extends* \[`Head`, `...Tails[]`\] ? \[`...(...)[]`\] *extends* \[\] ? \[\] : ... *extends* ... ? ... : ... : \[`...{ [K in (...)]: (...) }[]`\] : \[...\{ \[K in string \| number \| symbol\]: GetCreateQueryResult\<Tails\[K\<(...)\>\]\> \}\[\]\] : \{ \[K in string \| number \| symbol\]: GetCreateQueryResult\<T\[K\<K\>\]\> \}
## Parameters
### createQueriesOptions
[`Accessor`](../type-aliases/Accessor.md)\<\{
`combine?`: (`result`) => `TCombinedResult`;
`queries`: \| readonly \[`T` *extends* \[\] ? \[\] : `T` *extends* \[`Head`\] ? \[`GetCreateQueryOptionsForCreateQueries`\<`Head`\>\] : `T` *extends* \[`Head`, `...Tails[]`\] ? \[`...Tails[]`\] *extends* \[\] ? \[\] : \[`...Tails[]`\] *extends* \[`Head`\] ? \[`GetCreateQueryOptionsForCreateQueries`\<...\>, `GetCreateQueryOptionsForCreateQueries`\<...\>\] : \[`...(...)[]`\] *extends* \[..., `...(...)[]`\] ? ... *extends* ... ? ... : ... : ... *extends* ... ? ... : ... : readonly `unknown`[] *extends* `T` ? `T` : `T` *extends* `CreateQueryOptionsForCreateQueries`\<..., ..., ..., ...\>[] ? `CreateQueryOptionsForCreateQueries`\<..., ..., ..., ...\>[] : `CreateQueryOptionsForCreateQueries`\<..., ..., ..., ...\>[]\]
\| readonly \[\{ \[K in string \| number \| symbol\]: GetCreateQueryOptionsForCreateQueries\<T\[K\<K\>\]\> \}\];
\}\>
The `queries` array to run, and an optional `combine` function, wrapped in an
[Accessor](../type-aliases/Accessor.md) so options can be reactive.
### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context
will be used.
## Returns
`TCombinedResult`
An array with one result per query, in the same order as `queries` — or, if `combine` is provided,
whatever `combine` returns.
## Examples
```svelte
<script lang="ts">
import { createQueries } from '@tanstack/svelte-query'
let { ids }: { ids: Array<number> } = $props()
const postQueries = createQueries(() => ({
queries: ids.map((id) => ({
queryKey: ['post', id],
queryFn: () => fetchPost(id),
staleTime: Infinity,
})),
}))
</script>
<ul>
{#each postQueries as query, index (ids[index])}
{#if query.isPending}
<li>Loading...</li>
{:else if query.isError}
<li>Error: {query.error.message}</li>
{:else}
<li>{query.data.title}</li>
{/if}
{/each}
</ul>
```
Combining results into a single value:
```svelte
<script lang="ts">
import { createQueries } from '@tanstack/svelte-query'
let { ids }: { ids: Array<number> } = $props()
const combined = createQueries(() => ({
queries: ids.map((id) => ({
queryKey: ['post', id],
queryFn: () => fetchPost(id),
})),
combine: (postQueries) => ({
data: postQueries.map((query) => query.data),
isPending: postQueries.some((query) => query.isPending),
isError: postQueries.some((query) => query.isError),
}),
}))
</script>
{#if combined.isPending}
Loading...
{:else if combined.isError}
Error loading posts
{:else}
<ul>
{#each combined.data as post}
<li>{post?.title}</li>
{/each}
</ul>
{/if}
```

344
docs/framework/svelte/reference/functions/createQuery.md Normal file
View File

@@ -0,0 +1,344 @@
---
id: createQuery
title: createQuery
---
## Call Signature
```ts
function createQuery<TQueryFnData, TError, TData, TQueryKey>(options, queryClient?): CreateQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createQuery.ts:74](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createQuery.ts#L74)
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = `TQueryFnData`
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`UndefinedInitialDataOptions`](../type-aliases/UndefinedInitialDataOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>\>
The [UndefinedInitialDataOptions](../type-aliases/UndefinedInitialDataOptions.md) to use — everything you can pass to `createQuery`,
wrapped in an [Accessor](../type-aliases/Accessor.md) so options can be reactive.
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
### Returns
[`CreateQueryResult`](../type-aliases/CreateQueryResult.md)\<`TData`, `TError`\>
The current query result. `status` is `pending` if there is no cached data to display, `error` if
the last fetch attempt failed, or `success` if the query has data to display. `isPending`/`isSuccess`/`isError`
are derived booleans for convenience.
### See
[queryOptions](queryOptions.md) to share these options between `createQuery` and imperative APIs like `queryClient.query`.
### Examples
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['posts'],
queryFn: fetchPosts,
}))
</script>
{#if query.status === 'pending'}
Loading...
{:else if query.status === 'error'}
<span>Error: {query.error.message}</span>
{:else}
<ul>
{#each query.data as post (post.id)}
<li>{post.title}</li>
{/each}
</ul>
{/if}
```
The same query, checking `isPending`/`isError` instead of `status` — pick whichever reads better to you:
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['posts'],
queryFn: fetchPosts,
}))
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<ul>
{#each query.data as post (post.id)}
<li>{post.title}</li>
{/each}
</ul>
{/if}
```
## Call Signature
```ts
function createQuery<TQueryFnData, TError, TData, TQueryKey>(options, queryClient?): DefinedCreateQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createQuery.ts:122](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createQuery.ts#L122)
This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = `TQueryFnData`
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`DefinedInitialDataOptions`](../type-aliases/DefinedInitialDataOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>\>
The [DefinedInitialDataOptions](../type-aliases/DefinedInitialDataOptions.md) to use — everything you can pass to `createQuery`,
with `initialData` set, wrapped in an [Accessor](../type-aliases/Accessor.md) so options can be reactive.
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
### Returns
[`DefinedCreateQueryResult`](../type-aliases/DefinedCreateQueryResult.md)\<`TData`, `TError`\>
The current query result, typed so that `status` is `success` — or `error` if a fetch attempt
fails while keeping the existing data (`status` never resolves to `pending` in this overload's type,
since `initialData` guarantees data upfront). `isSuccess`/`isError` are derived booleans for convenience.
### See
[queryOptions](queryOptions.md) to share these options between `createQuery` and imperative APIs like `queryClient.query`.
### Example
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
// `data` is `Post[]`, never `undefined`, thanks to `initialData` — even if a refetch fails,
// so the list stays visible alongside the error.
const query = createQuery(() => ({
queryKey: ['posts'],
queryFn: fetchPosts,
initialData: [],
}))
</script>
{#if query.isError}
<span>Error: {query.error.message}</span>
{/if}
<ul>
{#each query.data as post (post.id)}
<li>{post.title}</li>
{/each}
</ul>
```
## Call Signature
```ts
function createQuery<TQueryFnData, TError, TData, TQueryKey>(options, queryClient?): CreateQueryResult<TData, TError>;
```
Defined in: [packages/svelte-query/src/createQuery.ts:248](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/createQuery.ts#L248)
### Type Parameters
#### TQueryFnData
`TQueryFnData`
#### TError
`TError` = `Error`
#### TData
`TData` = `TQueryFnData`
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
### Parameters
#### options
[`Accessor`](../type-aliases/Accessor.md)\<[`CreateQueryOptions`](../type-aliases/CreateQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>\>
The [CreateQueryOptions](../type-aliases/CreateQueryOptions.md) to use — everything you can pass to `createQuery`, wrapped
in an [Accessor](../type-aliases/Accessor.md) so options can be reactive.
#### queryClient?
[`Accessor`](../type-aliases/Accessor.md)\<[`QueryClient`](../classes/QueryClient.md)\>
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
### Returns
[`CreateQueryResult`](../type-aliases/CreateQueryResult.md)\<`TData`, `TError`\>
The current query result. `status` is `pending` if there is no cached data to display, `error` if
the last fetch attempt failed, or `success` if the query has data to display. `isPending`/`isSuccess`/`isError`
are derived booleans for convenience.
### See
[queryOptions](queryOptions.md) to share these options between `createQuery` and imperative APIs like `queryClient.query`.
### Examples
`select` derives whatever `data` a component needs from the cached value, without changing what's
actually stored in the cache — the cache still holds the full `Post[]`, but `data` here is a `number`:
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
const query = createQuery(() => ({
queryKey: ['posts'],
queryFn: fetchPosts,
select: (posts) => posts.length,
}))
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<span>{query.data} posts</span>
{/if}
```
A dependent query, only enabled once `postId` is set — use `isLoading`, not `isPending`, so the
loading state doesn't show while the query is disabled:
```svelte
<script lang="ts">
import { createQuery } from '@tanstack/svelte-query'
let { postId }: { postId: number | undefined } = $props()
const query = createQuery(() => ({
queryKey: ['post', postId],
queryFn: () => fetchPost(postId!),
enabled: postId != null,
}))
</script>
{#if postId == null}
Select a post
{:else if query.isLoading}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<h1>{query.data?.title}</h1>
{/if}
```
Seeding a detail query from an already-cached list, to skip the loading state:
```svelte
<script lang="ts">
import { createQuery, useQueryClient } from '@tanstack/svelte-query'
let { postId }: { postId: number } = $props()
const queryClient = useQueryClient()
const query = createQuery(() => ({
queryKey: ['post', postId],
queryFn: () => fetchPost(postId),
initialData: () =>
queryClient
.getQueryData<Array<Post>>(['posts'])
?.find((post) => post.id === postId),
}))
</script>
{#if query.isError}
<span>Error: {query.error.message}</span>
{/if}
<h1>{query.data?.title}</h1>
```
Paginated data, keeping the previous page's data visible while the next page loads:
```svelte
<script lang="ts">
import { createQuery, keepPreviousData } from '@tanstack/svelte-query'
let page = $state(0)
const query = createQuery(() => ({
queryKey: ['posts', page],
queryFn: () => fetchPosts(page),
placeholderData: keepPreviousData,
}))
</script>
{#if query.isError}
<span>Error: {query.error.message}</span>
{/if}
<ul>
{#each query.data ?? [] as post (post.id)}
<li>{post.title}</li>
{/each}
</ul>
<button disabled={query.isPlaceholderData} onclick={() => page++}>
Next Page
</button>
```

23
docs/framework/svelte/reference/functions/defaultShouldDehydrateMutation.md Normal file
View File

@@ -0,0 +1,23 @@
---
id: defaultShouldDehydrateMutation
title: defaultShouldDehydrateMutation
---
```ts
function defaultShouldDehydrateMutation(mutation): boolean;
```
Defined in: [packages/query-core/src/hydration.ts:177](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L177)
The default `shouldDehydrateMutation` predicate used by `dehydrate`. Only dehydrates mutations that are
currently paused (e.g. paused by `networkMode` while offline).
## Parameters
### mutation
[`Mutation`](../classes/Mutation.md)
## Returns
`boolean`

23
docs/framework/svelte/reference/functions/defaultShouldDehydrateQuery.md Normal file
View File

@@ -0,0 +1,23 @@
---
id: defaultShouldDehydrateQuery
title: defaultShouldDehydrateQuery
---
```ts
function defaultShouldDehydrateQuery(query): boolean;
```
Defined in: [packages/query-core/src/hydration.ts:185](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L185)
The default `shouldDehydrateQuery` predicate used by `dehydrate`. Only dehydrates queries whose status is
`'success'`.
## Parameters
### query
[`Query`](../classes/Query.md)
## Returns
`boolean`

43
docs/framework/svelte/reference/functions/dehydrate.md Normal file
View File

@@ -0,0 +1,43 @@
---
id: dehydrate
title: dehydrate
---
```ts
function dehydrate(client, options): DehydratedState;
```
Defined in: [packages/query-core/src/hydration.ts:207](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L207)
Dehydrates a `QueryClient`'s cache (queries and mutations) into a plain, serializable `DehydratedState`,
typically to embed in server-rendered markup and later restore into a client-side `QueryClient` via `hydrate`.
Which queries/mutations are included, and how their data/errors are transformed, is controlled by `options`,
falling back to the client's `dehydrate` default options, and finally to `defaultShouldDehydrateQuery` /
`defaultShouldDehydrateMutation`.
## Parameters
### client
[`QueryClient`](../classes/QueryClient.md)
### options
[`DehydrateOptions`](../interfaces/DehydrateOptions.md) = `{}`
## Returns
[`DehydratedState`](../interfaces/DehydratedState.md)
## Example
```ts
const queryClient = new QueryClient()
await queryClient.prefetchQuery({
queryKey: ['posts'],
queryFn: getPosts,
})
const dehydratedState = dehydrate(queryClient)
```

43
docs/framework/svelte/reference/functions/dehydrateQuery.md Normal file
View File

@@ -0,0 +1,43 @@
---
id: dehydrateQuery
title: dehydrateQuery
---
```ts
function dehydrateQuery(
query,
serializeData?,
shouldRedactErrors?): DehydratedQuery;
```
Defined in: [packages/query-core/src/hydration.ts:148](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L148)
Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.
`queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the
de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight
promise is dehydrated too so it can be resumed on the other side instead of re-fetched.
## Parameters
### query
[`Query`](../classes/Query.md)
The query to dehydrate.
### serializeData?
`TransformerFn`
Optional transform applied to `query.state.data` before it is included in the snapshot.
### shouldRedactErrors?
(`error`) => `boolean`
Optional predicate; if it returns `false` for the promise's rejection error, that
error is kept as-is instead of being redacted.
## Returns
`DehydratedQuery`

52
docs/framework/svelte/reference/functions/experimental_streamedQuery.md Normal file
View File

@@ -0,0 +1,52 @@
---
id: experimental_streamedQuery
title: experimental_streamedQuery
---
```ts
function experimental_streamedQuery<TQueryFnData, TData, TQueryKey>(streamFn): QueryFunction<TData, TQueryKey>;
```
Defined in: [packages/query-core/src/streamedQuery.ts:75](https://github.com/TanStack/query/blob/main/packages/query-core/src/streamedQuery.ts#L75)
This is a helper function to create a query function that streams data from an AsyncIterable.
Data will be an Array of all the chunks received.
The query will be in a 'pending' state until the first chunk of data is received, but will go to 'success' after that.
The query will stay in fetchStatus 'fetching' until the stream ends.
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TData
`TData` = `TQueryFnData`[]
### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
## Parameters
### streamFn
`StreamedQueryParams`\<`TQueryFnData`, `TData`, `TQueryKey`\>
The function that returns an AsyncIterable to stream data from.
## Returns
[`QueryFunction`](../type-aliases/QueryFunction.md)\<`TData`, `TQueryKey`\>
## Example
```ts
await queryClient.query({
queryKey: ['data'],
queryFn: streamedQuery({
streamFn: fetchDataInChunks,
}),
})
```

16
docs/framework/svelte/reference/functions/getIsRestoringContext.md Normal file
View File

@@ -0,0 +1,16 @@
---
id: getIsRestoringContext
title: getIsRestoringContext
---
```ts
function getIsRestoringContext(): Box<boolean>;
```
Defined in: [packages/svelte-query/src/context.ts:52](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/context.ts#L52)
Retrieves a `isRestoring` from Svelte's context
## Returns
`Box`\<`boolean`\>

23
docs/framework/svelte/reference/functions/getQueryClientContext.md Normal file
View File

@@ -0,0 +1,23 @@
---
id: getQueryClientContext
title: getQueryClientContext
---
```ts
function getQueryClientContext(): QueryClient;
```
Defined in: [packages/svelte-query/src/context.ts:14](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/context.ts#L14)
Retrieves the `QueryClient` set on Svelte's context by `QueryClientProvider` (or by
[setQueryClientContext](setQueryClientContext.md) directly). This is what [useQueryClient](useQueryClient.md) calls internally.
## Returns
[`QueryClient`](../classes/QueryClient.md)
The `QueryClient` set on context, whether by `QueryClientProvider` or [setQueryClientContext](setQueryClientContext.md).
## Throws
If no `QueryClient` was found in context.

30
docs/framework/svelte/reference/functions/hashKey.md Normal file
View File

@@ -0,0 +1,30 @@
---
id: hashKey
title: hashKey
---
```ts
function hashKey(queryKey): string;
```
Defined in: [packages/query-core/src/utils.ts:284](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L284)
Default query & mutation keys hash function.
Hashes the value into a stable hash.
## Parameters
### queryKey
readonly `unknown`[]
## Returns
`string`
## Example
```ts
// Object keys are sorted, so key order doesn't affect the hash:
hashKey(['todos', { page: 1, filter: 'done' }]) // === '["todos",{"filter":"done","page":1}]'
```

49
docs/framework/svelte/reference/functions/hydrate.md Normal file
View File

@@ -0,0 +1,49 @@
---
id: hydrate
title: hydrate
---
```ts
function hydrate(
client,
dehydratedState,
options?): void;
```
Defined in: [packages/query-core/src/hydration.ts:264](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L264)
Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the
client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.
Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated
when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset
to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight
promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking
`queryFn`.
## Parameters
### client
[`QueryClient`](../classes/QueryClient.md)
### dehydratedState
`Partial`\<[`DehydratedState`](../interfaces/DehydratedState.md)\>
### options?
[`HydrateOptions`](../interfaces/HydrateOptions.md)
## Returns
`void`
## Example
```ts
// dehydratedState was produced by `dehydrate` on the server
// and sent to the client, e.g. embedded in server-rendered markup.
const queryClient = new QueryClient()
hydrate(queryClient, dehydratedState)
```

178
docs/framework/svelte/reference/functions/infiniteQueryOptions.md Normal file
View File

@@ -0,0 +1,178 @@
---
id: infiniteQueryOptions
title: infiniteQueryOptions
---
## Call Signature
```ts
function infiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & object & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData, unknown>, TError>;
```
Defined in: [packages/svelte-query/src/infiniteQueryOptions.ts:92](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/infiniteQueryOptions.ts#L92)
You can generally pass everything to `infiniteQueryOptions` that you can also pass to `createInfiniteQuery`.
These options can be shared across `createInfiniteQuery` calls and imperative APIs such as
`queryClient.infiniteQuery`. `options.queryKey` is required and is the query key to generate options for.
This overload is selected when `initialData` is set.
### Type Parameters
#### TQueryFnData
`TQueryFnData`
#### TError
`TError` = `Error`
#### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### TPageParam
`TPageParam` = `unknown`
### Parameters
#### options
[`DefinedInitialDataInfiniteOptions`](../type-aliases/DefinedInitialDataInfiniteOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
The [DefinedInitialDataInfiniteOptions](../type-aliases/DefinedInitialDataInfiniteOptions.md) to use — everything you can pass to
`createInfiniteQuery`, with `initialData` set.
### Returns
[`CreateInfiniteQueryOptions`](../type-aliases/CreateInfiniteQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\> & `object` & [`QueryKeyWithDataTag`](../type-aliases/QueryKeyWithDataTag.md)\<`TQueryKey`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>, `TError`\>
The same options object, typed so that `queryKey` carries the inferred data type.
### See
[createInfiniteQuery](createInfiniteQuery.md) to run an infinite query with these options.
### Example
`initialData` skips the loading state on first render — even if a refetch fails, the list stays
visible alongside the error:
```svelte
<script lang="ts">
import { infiniteQueryOptions, createInfiniteQuery } from '@tanstack/svelte-query'
const projectsOptions = infiniteQueryOptions({
queryKey: ['projects'],
queryFn: ({ pageParam }) => fetchProjects(pageParam),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
initialData: { pages: [], pageParams: [] },
})
const query = createInfiniteQuery(() => projectsOptions)
</script>
{#if query.isError}
<span>Error: {query.error.message}</span>
{/if}
<ul>
{#each query.data.pages as page}
{#each page.projects as project (project.id)}
<li>{project.name}</li>
{/each}
{/each}
</ul>
```
## Call Signature
```ts
function infiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & object & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData, unknown>, TError>;
```
Defined in: [packages/svelte-query/src/infiniteQueryOptions.ts:159](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/infiniteQueryOptions.ts#L159)
You can generally pass everything to `infiniteQueryOptions` that you can also pass to `createInfiniteQuery`.
These options can be shared across `createInfiniteQuery` calls and imperative APIs such as
`queryClient.infiniteQuery`. `options.queryKey` is required and is the query key to generate options for.
### Type Parameters
#### TQueryFnData
`TQueryFnData`
#### TError
`TError` = `Error`
#### TData
`TData` = [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
#### TPageParam
`TPageParam` = `unknown`
### Parameters
#### options
[`UndefinedInitialDataInfiniteOptions`](../type-aliases/UndefinedInitialDataInfiniteOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
The [UndefinedInitialDataInfiniteOptions](../type-aliases/UndefinedInitialDataInfiniteOptions.md) to use — everything you can pass to
`createInfiniteQuery`.
### Returns
[`CreateInfiniteQueryOptions`](../type-aliases/CreateInfiniteQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\> & `object` & [`QueryKeyWithDataTag`](../type-aliases/QueryKeyWithDataTag.md)\<`TQueryKey`, [`InfiniteData`](../interfaces/InfiniteData.md)\<`TQueryFnData`, `unknown`\>, `TError`\>
The same options object, typed so that `queryKey` carries the inferred data type.
### See
[createInfiniteQuery](createInfiniteQuery.md) to run an infinite query with these options.
### Example
A parameterized factory, so the same options object can be reused per `postId`:
```svelte
<script lang="ts">
import { infiniteQueryOptions, createInfiniteQuery } from '@tanstack/svelte-query'
let { postId }: { postId: string } = $props()
const commentsOptions = (postId: string) =>
infiniteQueryOptions({
queryKey: ['post', postId, 'comments'],
queryFn: ({ pageParam }) => fetchComments(postId, pageParam),
initialPageParam: 0,
getNextPageParam: (lastPage) => lastPage.nextId,
})
const query = createInfiniteQuery(() => commentsOptions(postId))
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<ul>
{#each query.data.pages as page}
{#each page.comments as comment (comment.id)}
<li>{comment.text}</li>
{/each}
{/each}
</ul>
{/if}
```

24
docs/framework/svelte/reference/functions/isCancelledError.md Normal file
View File

@@ -0,0 +1,24 @@
---
id: isCancelledError
title: isCancelledError
---
```ts
function isCancelledError(value): value is CancelledError;
```
Defined in: [packages/query-core/src/retryer.ts:90](https://github.com/TanStack/query/blob/main/packages/query-core/src/retryer.ts#L90)
## Parameters
### value
`any`
## Returns
`value is CancelledError`
## Deprecated
Use instanceof `CancelledError` instead.

40
docs/framework/svelte/reference/functions/keepPreviousData.md Normal file
View File

@@ -0,0 +1,40 @@
---
id: keepPreviousData
title: keepPreviousData
---
```ts
function keepPreviousData<T>(previousData): T | undefined;
```
Defined in: [packages/query-core/src/utils.ts:493](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L493)
Intended to be passed as a query's `placeholderData` option, for example
`placeholderData: keepPreviousData`. Instead of resetting the query's data to `undefined` while a new
query key is fetching, it keeps displaying the previously fetched data until the new data arrives.
## Type Parameters
### T
`T`
## Parameters
### previousData
`T` | `undefined`
## Returns
`T` \| `undefined`
## Example
```ts
new QueryObserver(queryClient, {
queryKey: ['posts', page],
queryFn: () => fetchPosts(page),
placeholderData: keepPreviousData,
})
```

38
docs/framework/svelte/reference/functions/matchMutation.md Normal file
View File

@@ -0,0 +1,38 @@
---
id: matchMutation
title: matchMutation
---
```ts
function matchMutation(filters, mutation): boolean;
```
Defined in: [packages/query-core/src/utils.ts:237](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L237)
Checks whether a mutation matches the given [MutationFilters](../interfaces/MutationFilters.md).
Every filter that is specified must match; filters that are left unspecified are ignored.
If a `mutationKey` filter is provided but the mutation has no `mutationKey` of its own, it does not match.
## Parameters
### filters
[`MutationFilters`](../interfaces/MutationFilters.md)
### mutation
[`Mutation`](../classes/Mutation.md)\<`any`, `any`\>
## Returns
`boolean`
## Example
```ts
const mutationCache = queryClient.getMutationCache()
const matchingMutations = mutationCache
.getAll()
.filter((mutation) => matchMutation({ mutationKey: ['addPost'] }, mutation))
```

37
docs/framework/svelte/reference/functions/matchQuery.md Normal file
View File

@@ -0,0 +1,37 @@
---
id: matchQuery
title: matchQuery
---
```ts
function matchQuery(filters, query): boolean;
```
Defined in: [packages/query-core/src/utils.ts:175](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L175)
Checks whether a query matches the given [QueryFilters](../interfaces/QueryFilters.md).
Every filter that is specified must match; filters that are left unspecified are ignored.
## Parameters
### filters
[`QueryFilters`](../interfaces/QueryFilters.md)
### query
[`Query`](../classes/Query.md)\<`any`, `any`, `any`, `any`\>
## Returns
`boolean`
## Example
```ts
const queryCache = queryClient.getQueryCache()
const matchingQueries = queryCache
.getAll()
.filter((query) => matchQuery({ queryKey: ['posts'] }, query))
```

136
docs/framework/svelte/reference/functions/mutationOptions.md Normal file
View File

@@ -0,0 +1,136 @@
---
id: mutationOptions
title: mutationOptions
---
## Call Signature
```ts
function mutationOptions<TData, TError, TVariables, TOnMutateResult>(options): WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, "mutationKey">;
```
Defined in: [packages/svelte-query/src/mutationOptions.ts:34](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/mutationOptions.ts#L34)
You can generally pass everything to `mutationOptions` that you can also pass to `createMutation`. This
overload requires `mutationKey`, so the resulting options can be looked up elsewhere (e.g. with
`useMutationState`).
### Type Parameters
#### TData
`TData` = `unknown`
#### TError
`TError` = `Error`
#### TVariables
`TVariables` = `void`
#### TOnMutateResult
`TOnMutateResult` = `unknown`
### Parameters
#### options
[`WithRequired`](../type-aliases/WithRequired.md)\<[`CreateMutationOptions`](../type-aliases/CreateMutationOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>, `"mutationKey"`\>
The options to use — everything you can pass to `createMutation`, with `mutationKey` set.
### Returns
[`WithRequired`](../type-aliases/WithRequired.md)\<[`CreateMutationOptions`](../type-aliases/CreateMutationOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>, `"mutationKey"`\>
The same options object.
### See
[createMutation](createMutation.md) to run a mutation with these options.
### Example
Looking the mutation up elsewhere via its `mutationKey`, e.g. for a global "saving…" indicator:
```svelte
<script lang="ts">
import { mutationOptions, useMutationState } from '@tanstack/svelte-query'
const createPostOptions = mutationOptions({
mutationKey: ['posts', 'create'],
mutationFn: createPost,
})
const pending = useMutationState({
filters: { mutationKey: createPostOptions.mutationKey, status: 'pending' },
})
</script>
{#if pending.length > 0}
<span>Saving…</span>
{/if}
```
## Call Signature
```ts
function mutationOptions<TData, TError, TVariables, TOnMutateResult>(options): Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, "mutationKey">;
```
Defined in: [packages/svelte-query/src/mutationOptions.ts:71](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/mutationOptions.ts#L71)
You can generally pass everything to `mutationOptions` that you can also pass to `createMutation`.
### Type Parameters
#### TData
`TData` = `unknown`
#### TError
`TError` = `Error`
#### TVariables
`TVariables` = `void`
#### TOnMutateResult
`TOnMutateResult` = `unknown`
### Parameters
#### options
`Omit`\<[`CreateMutationOptions`](../type-aliases/CreateMutationOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>, `"mutationKey"`\>
The options to use — everything you can pass to `createMutation`.
### Returns
`Omit`\<[`CreateMutationOptions`](../type-aliases/CreateMutationOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>, `"mutationKey"`\>
The same options object.
### See
[createMutation](createMutation.md) to run a mutation with these options.
### Example
```svelte
<script lang="ts">
import { mutationOptions, createMutation } from '@tanstack/svelte-query'
const createPostOptions = mutationOptions({
mutationFn: createPost,
})
const mutation = createMutation(() => createPostOptions)
</script>
<button onclick={() => mutation.mutate({ title: 'Hello' })}>Create</button>
```

32
docs/framework/svelte/reference/functions/noop.md Normal file
View File

@@ -0,0 +1,32 @@
---
id: noop
title: noop
---
## Call Signature
```ts
function noop(): void;
```
Defined in: [packages/query-core/src/utils.ts:119](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L119)
A function that does nothing.
### Returns
`void`
## Call Signature
```ts
function noop(): undefined;
```
Defined in: [packages/query-core/src/utils.ts:120](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L120)
A function that does nothing.
### Returns
`undefined`

26
docs/framework/svelte/reference/functions/partialMatchKey.md Normal file
View File

@@ -0,0 +1,26 @@
---
id: partialMatchKey
title: partialMatchKey
---
```ts
function partialMatchKey(a, b): boolean;
```
Defined in: [packages/query-core/src/utils.ts:300](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L300)
Checks if key `b` partially matches with key `a`.
## Parameters
### a
readonly `unknown`[]
### b
readonly `unknown`[]
## Returns
`boolean`

157
docs/framework/svelte/reference/functions/queryOptions.md Normal file
View File

@@ -0,0 +1,157 @@
---
id: queryOptions
title: queryOptions
---
## Call Signature
```ts
function queryOptions<TQueryFnData, TError, TData, TQueryKey>(options): CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & object & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
```
Defined in: [packages/svelte-query/src/queryOptions.ts:68](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/queryOptions.ts#L68)
You can generally pass everything to `queryOptions` that you can also pass to `createQuery`. These options
can be shared across `createQuery` calls and imperative APIs such as `queryClient.query`. `options.queryKey`
is required and is the query key to generate options for.
This overload is selected when `initialData` is set, so the resulting `data` is never `undefined`.
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = `TQueryFnData`
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
### Parameters
#### options
[`DefinedInitialDataOptions`](../type-aliases/DefinedInitialDataOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
The [DefinedInitialDataOptions](../type-aliases/DefinedInitialDataOptions.md) to use — everything you can pass to `createQuery`,
with `initialData` set.
### Returns
[`CreateQueryOptions`](../type-aliases/CreateQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\> & `object` & [`QueryKeyWithDataTag`](../type-aliases/QueryKeyWithDataTag.md)\<`TQueryKey`, `TQueryFnData`, `TError`\>
The same options object, typed so that `queryKey` carries the inferred data type.
### See
[createQuery](createQuery.md) to run a query with these options.
### Example
```svelte
<script lang="ts">
import { queryOptions, createQuery } from '@tanstack/svelte-query'
const postsOptions = queryOptions({
queryKey: ['posts'],
queryFn: fetchPosts,
initialData: [],
})
// `data` is `Post[]`, never `undefined`, thanks to `initialData` — even if a refetch fails,
// so the list stays visible alongside the error.
const query = createQuery(() => postsOptions)
</script>
{#if query.isError}
<span>Error: {query.error.message}</span>
{/if}
<ul>
{#each query.data as post (post.id)}
<li>{post.title}</li>
{/each}
</ul>
```
## Call Signature
```ts
function queryOptions<TQueryFnData, TError, TData, TQueryKey>(options): CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & object & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
```
Defined in: [packages/svelte-query/src/queryOptions.ts:113](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/queryOptions.ts#L113)
You can generally pass everything to `queryOptions` that you can also pass to `createQuery`. These options
can be shared across `createQuery` calls and imperative APIs such as `queryClient.query`. `options.queryKey`
is required and is the query key to generate options for.
### Type Parameters
#### TQueryFnData
`TQueryFnData` = `unknown`
#### TError
`TError` = `Error`
#### TData
`TData` = `TQueryFnData`
#### TQueryKey
`TQueryKey` *extends* readonly `unknown`[] = readonly `unknown`[]
### Parameters
#### options
[`UndefinedInitialDataOptions`](../type-aliases/UndefinedInitialDataOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\>
The [UndefinedInitialDataOptions](../type-aliases/UndefinedInitialDataOptions.md) to use — everything you can pass to `createQuery`.
### Returns
[`CreateQueryOptions`](../type-aliases/CreateQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`\> & `object` & [`QueryKeyWithDataTag`](../type-aliases/QueryKeyWithDataTag.md)\<`TQueryKey`, `TQueryFnData`, `TError`\>
The same options object, typed so that `queryKey` carries the inferred data type.
### See
[createQuery](createQuery.md) to run a query with these options.
### Example
A parameterized factory, so the same options object can be reused per `id`:
```svelte
<script lang="ts">
import { queryOptions, createQuery } from '@tanstack/svelte-query'
let { id }: { id: string } = $props()
const postOptions = (id: string) =>
queryOptions({
queryKey: ['post', id],
queryFn: () => fetchPost(id),
})
const query = createQuery(() => postOptions(id))
</script>
{#if query.isPending}
Loading...
{:else if query.isError}
<span>Error: {query.error.message}</span>
{:else}
<h1>{query.data.title}</h1>
{/if}
```

41
docs/framework/svelte/reference/functions/replaceEqualDeep.md Normal file
View File

@@ -0,0 +1,41 @@
---
id: replaceEqualDeep
title: replaceEqualDeep
---
```ts
function replaceEqualDeep<T>(
a,
b,
depth?): T;
```
Defined in: [packages/query-core/src/utils.ts:339](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L339)
This function returns `a` if `b` is deeply equal.
If not, it will replace any deeply equal children of `b` with those of `a`.
This can be used for structural sharing between JSON values for example.
## Type Parameters
### T
`T`
## Parameters
### a
`unknown`
### b
`T`
### depth?
`number`
## Returns
`T`

22
docs/framework/svelte/reference/functions/setIsRestoringContext.md Normal file
View File

@@ -0,0 +1,22 @@
---
id: setIsRestoringContext
title: setIsRestoringContext
---
```ts
function setIsRestoringContext(isRestoring): void;
```
Defined in: [packages/svelte-query/src/context.ts:64](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/context.ts#L64)
Sets a `isRestoring` on Svelte's context
## Parameters
### isRestoring
`Box`\<`boolean`\>
## Returns
`void`

40
docs/framework/svelte/reference/functions/setQueryClientContext.md Normal file
View File

@@ -0,0 +1,40 @@
---
id: setQueryClientContext
title: setQueryClientContext
---
```ts
function setQueryClientContext(client): void;
```
Defined in: [packages/svelte-query/src/context.ts:45](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/context.ts#L45)
Sets a `QueryClient` on Svelte's context, so it can be read with [getQueryClientContext](getQueryClientContext.md) (or
[useQueryClient](useQueryClient.md)) from any descendant component. `QueryClientProvider` wraps this — use it directly
only if you need to set the client from your own component instead.
## Parameters
### client
[`QueryClient`](../classes/QueryClient.md)
The `QueryClient` to make available to descendant components.
## Returns
`void`
## Example
```svelte
<script lang="ts">
import { QueryClient, QueryClientProvider } from '@tanstack/svelte-query'
const queryClient = new QueryClient()
</script>
<QueryClientProvider client={queryClient}>
...
</QueryClientProvider>
```

45
docs/framework/svelte/reference/functions/shouldThrowError.md Normal file
View File

@@ -0,0 +1,45 @@
---
id: shouldThrowError
title: shouldThrowError
---
```ts
function shouldThrowError<T>(throwOnError, params): boolean;
```
Defined in: [packages/query-core/src/utils.ts:576](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L576)
Resolves a `throwOnError` option to a boolean.
If `throwOnError` is a function, it is called with `params` (e.g. the error and, depending on the caller,
additional context such as the query or mutation) and its result is returned, allowing the throwing
behavior to be decided per error. Otherwise, `throwOnError` itself is coerced to a boolean (`undefined`
resolves to `false`).
## Type Parameters
### T
`T` *extends* (...`args`) => `boolean`
## Parameters
### throwOnError
`boolean` | `T` | `undefined`
### params
`Parameters`\<`T`\>
## Returns
`boolean`
## Example
```ts
const throwOnError =
query.state.error && typeof options.throwOnError === 'function'
? shouldThrowError(options.throwOnError, [query.state.error, query])
: options.throwOnError
```

61
docs/framework/svelte/reference/functions/useHydrate.md Normal file
View File

@@ -0,0 +1,61 @@
---
id: useHydrate
title: useHydrate
---
```ts
function useHydrate(
state?,
options?,
queryClient?): void;
```
Defined in: [packages/svelte-query/src/useHydrate.ts:33](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useHydrate.ts#L33)
Adds a previously dehydrated `state` into the `queryClient` (from the nearest context, or the one
passed explicitly). If the client already contains data, the new queries will be intelligently merged based
on update timestamp. `HydrationBoundary` wraps this — use it directly only if you need to hydrate from your
own component instead.
## Parameters
### state?
`unknown`
The dehydrated state to hydrate into the cache, as produced by `dehydrate`.
### options?
[`HydrateOptions`](../interfaces/HydrateOptions.md)
[HydrateOptions](../interfaces/HydrateOptions.md) to control the hydration.
### queryClient?
[`QueryClient`](../classes/QueryClient.md)
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
## Returns
`void`
## Example
Server-side prefetch handed off to the client via `dehydrate` — `dehydratedState` would typically come
from a server load function that prefetched with `queryClient.query` and called `dehydrate(queryClient)`:
```svelte
<script lang="ts">
import { HydrationBoundary } from '@tanstack/svelte-query'
import type { DehydratedState } from '@tanstack/svelte-query'
import Posts from './Posts.svelte'
let { dehydratedState }: { dehydratedState: DehydratedState } = $props()
</script>
<HydrationBoundary state={dehydratedState}>
<Posts />
</HydrationBoundary>
```

60
docs/framework/svelte/reference/functions/useIsFetching.md Normal file
View File

@@ -0,0 +1,60 @@
---
id: useIsFetching
title: useIsFetching
---
```ts
function useIsFetching(filters?, queryClient?): ReactiveValue<number>;
```
Defined in: [packages/svelte-query/src/useIsFetching.svelte.ts:40](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useIsFetching.svelte.ts#L40)
## Parameters
### filters?
[`QueryFilters`](../interfaces/QueryFilters.md)\<readonly `unknown`[]\>
[QueryFilters](../interfaces/QueryFilters.md) to narrow down which queries to count. Omit to count every fetching
query.
### queryClient?
[`QueryClient`](../classes/QueryClient.md)
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
## Returns
`ReactiveValue`\<`number`\>
A reactive value — read `.current` to get how many matching queries are currently fetching.
## Examples
```svelte
<script lang="ts">
import { useIsFetching } from '@tanstack/svelte-query'
// How many queries matching the posts prefix are fetching?
const isFetchingPosts = useIsFetching({ queryKey: ['posts'] })
</script>
{#if isFetchingPosts.current}
<span>Refreshing posts...</span>
{/if}
```
A global loading indicator for any query fetching in the background, not just the ones on screen:
```svelte
<script lang="ts">
import { useIsFetching } from '@tanstack/svelte-query'
const isFetching = useIsFetching()
</script>
{#if isFetching.current}
<div>Queries are fetching in the background...</div>
{/if}
```

49
docs/framework/svelte/reference/functions/useIsMutating.md Normal file
View File

@@ -0,0 +1,49 @@
---
id: useIsMutating
title: useIsMutating
---
```ts
function useIsMutating(filters?, queryClient?): ReactiveValue<number>;
```
Defined in: [packages/svelte-query/src/useIsMutating.svelte.ts:28](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useIsMutating.svelte.ts#L28)
`useIsMutating` is an optional hook that returns the `number` of mutations that your application is
running (useful for app-wide loading indicators).
## Parameters
### filters?
[`MutationFilters`](../interfaces/MutationFilters.md)\<`unknown`, `Error`, `unknown`, `unknown`\>
[MutationFilters](../interfaces/MutationFilters.md) to narrow down which mutations to count.
### queryClient?
[`QueryClient`](../classes/QueryClient.md)
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
## Returns
`ReactiveValue`\<`number`\>
A reactive value — read `.current` to get how many matching mutations are currently running.
## Example
```svelte
<script lang="ts">
import { useIsMutating } from '@tanstack/svelte-query'
// How many mutations matching the posts prefix are in progress?
const isMutatingPosts = useIsMutating({ mutationKey: ['posts'] })
</script>
{#if isMutatingPosts.current}
<span>Saving posts...</span>
{/if}
```

14
docs/framework/svelte/reference/functions/useIsRestoring.md Normal file
View File

@@ -0,0 +1,14 @@
---
id: useIsRestoring
title: useIsRestoring
---
```ts
function useIsRestoring(): Box<boolean>;
```
Defined in: [packages/svelte-query/src/useIsRestoring.ts:4](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useIsRestoring.ts#L4)
## Returns
`Box`\<`boolean`\>

104
docs/framework/svelte/reference/functions/useMutationState.md Normal file
View File

@@ -0,0 +1,104 @@
---
id: useMutationState
title: useMutationState
---
```ts
function useMutationState<TResult, TMutation>(options, queryClient?): TResult[];
```
Defined in: [packages/svelte-query/src/useMutationState.svelte.ts:99](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useMutationState.svelte.ts#L99)
`useMutationState` gives you access to all mutations (matching the given `filters`), including ones that
were created by a different component or hook instance, or even ones no longer mounted.
## Type Parameters
### TResult
`TResult` = [`MutationState`](../interfaces/MutationState.md)\<`unknown`, `Error`, `unknown`, `unknown`\>
### TMutation
`TMutation` *extends* [`Mutation`](../classes/Mutation.md)\<`any`, `any`, `any`, `any`\> = [`MutationTypeFromResult`](../type-aliases/MutationTypeFromResult.md)\<`TResult`\>
## Parameters
### options
[`MutationStateOptions`](../type-aliases/MutationStateOptions.md)\<`TResult`, `TMutation`\> = `{}`
The `filters` to narrow down matched mutations, and an optional `select` to transform the
mutation state.
### queryClient?
[`QueryClient`](../classes/QueryClient.md)
Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
be used.
## Returns
`TResult`[]
An Array of whatever `select` returns for each matching mutation.
## Examples
Get all variables of all running mutations:
```svelte
<script lang="ts">
import { useMutationState } from '@tanstack/svelte-query'
const pendingVariables = useMutationState({
filters: { status: 'pending' },
select: (mutation) => mutation.state.variables,
})
</script>
{pendingVariables.length} posts saving...
```
Get all data for specific mutations via the `mutationKey`:
```svelte
<script lang="ts">
import { createMutation, useMutationState } from '@tanstack/svelte-query'
const mutationKey = ['posts']
// Some mutation that we want to get the state for
const mutation = createMutation(() => ({
mutationKey,
mutationFn: createPosts,
}))
const savedPosts = useMutationState({
// this mutation key needs to match the mutation key of the given mutation (see above)
filters: { mutationKey, status: 'success' },
select: (mutation) => mutation.state.data,
})
</script>
<button onclick={() => mutation.mutate(['New Post'])}>
Create post ({savedPosts.length} saved so far)
</button>
```
Access the latest mutation data via the `mutationKey`. Each invocation of `mutate` adds a new entry to the
mutation cache for `gcTime` milliseconds — check the last item that `useMutationState` returns to get the
latest successful mutation (the `status: 'success'` filter above excludes pending/errored ones):
```svelte
<script lang="ts">
import { useMutationState } from '@tanstack/svelte-query'
const savedPosts = useMutationState({
filters: { mutationKey: ['posts'], status: 'success' },
select: (mutation) => mutation.state.data,
})
const latestSavedPost = $derived(savedPosts[savedPosts.length - 1])
</script>
{latestSavedPost ? 'Saved' : 'Nothing saved yet'}
```

20
docs/framework/svelte/reference/functions/useQueryClient.md Normal file
View File

@@ -0,0 +1,20 @@
---
id: useQueryClient
title: useQueryClient
---
```ts
function useQueryClient(queryClient?): QueryClient;
```
Defined in: [packages/svelte-query/src/useQueryClient.ts:4](https://github.com/TanStack/query/blob/main/packages/svelte-query/src/useQueryClient.ts#L4)
## Parameters
### queryClient?
[`QueryClient`](../classes/QueryClient.md)
## Returns
[`QueryClient`](../classes/QueryClient.md)

221
docs/framework/svelte/reference/index.md Normal file
View File

@@ -0,0 +1,221 @@
---
id: "@tanstack/svelte-query"
title: "@tanstack/svelte-query"
---
## Classes
- [CancelledError](classes/CancelledError.md)
- [InfiniteQueryObserver](classes/InfiniteQueryObserver.md)
- [Mutation](classes/Mutation.md)
- [MutationCache](classes/MutationCache.md)
- [MutationObserver](classes/MutationObserver.md)
- [QueriesObserver](classes/QueriesObserver.md)
- [Query](classes/Query.md)
- [QueryCache](classes/QueryCache.md)
- [QueryClient](classes/QueryClient.md)
- [QueryObserver](classes/QueryObserver.md)
## Interfaces
- [CancelOptions](interfaces/CancelOptions.md)
- [DefaultOptions](interfaces/DefaultOptions.md)
- [DehydratedState](interfaces/DehydratedState.md)
- [DehydrateOptions](interfaces/DehydrateOptions.md)
- [~~EnsureQueryDataOptions~~](interfaces/EnsureQueryDataOptions.md)
- [FetchNextPageOptions](interfaces/FetchNextPageOptions.md)
- [FetchPreviousPageOptions](interfaces/FetchPreviousPageOptions.md)
- [~~FetchQueryOptions~~](interfaces/FetchQueryOptions.md)
- [FocusManager](interfaces/FocusManager.md)
- [HydrateOptions](interfaces/HydrateOptions.md)
- [InfiniteData](interfaces/InfiniteData.md)
- [InfiniteQueryObserverBaseResult](interfaces/InfiniteQueryObserverBaseResult.md)
- [InfiniteQueryObserverLoadingErrorResult](interfaces/InfiniteQueryObserverLoadingErrorResult.md)
- [InfiniteQueryObserverLoadingResult](interfaces/InfiniteQueryObserverLoadingResult.md)
- [InfiniteQueryObserverOptions](interfaces/InfiniteQueryObserverOptions.md)
- [InfiniteQueryObserverPendingResult](interfaces/InfiniteQueryObserverPendingResult.md)
- [InfiniteQueryObserverPlaceholderResult](interfaces/InfiniteQueryObserverPlaceholderResult.md)
- [InfiniteQueryObserverRefetchErrorResult](interfaces/InfiniteQueryObserverRefetchErrorResult.md)
- [InfiniteQueryObserverSuccessResult](interfaces/InfiniteQueryObserverSuccessResult.md)
- [InfiniteQueryPageParamsOptions](interfaces/InfiniteQueryPageParamsOptions.md)
- [InitialPageParam](interfaces/InitialPageParam.md)
- [InvalidateOptions](interfaces/InvalidateOptions.md)
- [InvalidateQueryFilters](interfaces/InvalidateQueryFilters.md)
- [MutateOptions](interfaces/MutateOptions.md)
- [MutationCacheConfig](interfaces/MutationCacheConfig.md)
- [MutationFilters](interfaces/MutationFilters.md)
- [MutationObserverBaseResult](interfaces/MutationObserverBaseResult.md)
- [MutationObserverErrorResult](interfaces/MutationObserverErrorResult.md)
- [MutationObserverIdleResult](interfaces/MutationObserverIdleResult.md)
- [MutationObserverLoadingResult](interfaces/MutationObserverLoadingResult.md)
- [MutationObserverOptions](interfaces/MutationObserverOptions.md)
- [MutationObserverSuccessResult](interfaces/MutationObserverSuccessResult.md)
- [MutationOptions](interfaces/MutationOptions.md)
- [MutationState](interfaces/MutationState.md)
- [NotifyEvent](interfaces/NotifyEvent.md)
- [OnlineManager](interfaces/OnlineManager.md)
- [QueriesObserverOptions](interfaces/QueriesObserverOptions.md)
- [QueryCacheConfig](interfaces/QueryCacheConfig.md)
- [QueryClientConfig](interfaces/QueryClientConfig.md)
- [QueryExecuteOptions](interfaces/QueryExecuteOptions.md)
- [QueryFilters](interfaces/QueryFilters.md)
- [QueryObserverBaseResult](interfaces/QueryObserverBaseResult.md)
- [QueryObserverLoadingErrorResult](interfaces/QueryObserverLoadingErrorResult.md)
- [QueryObserverLoadingResult](interfaces/QueryObserverLoadingResult.md)
- [QueryObserverOptions](interfaces/QueryObserverOptions.md)
- [QueryObserverPendingResult](interfaces/QueryObserverPendingResult.md)
- [QueryObserverPlaceholderResult](interfaces/QueryObserverPlaceholderResult.md)
- [QueryObserverRefetchErrorResult](interfaces/QueryObserverRefetchErrorResult.md)
- [QueryObserverSuccessResult](interfaces/QueryObserverSuccessResult.md)
- [QueryOptions](interfaces/QueryOptions.md)
- [QueryState](interfaces/QueryState.md)
- [RefetchOptions](interfaces/RefetchOptions.md)
- [RefetchQueryFilters](interfaces/RefetchQueryFilters.md)
- [Register](interfaces/Register.md)
- [ResetOptions](interfaces/ResetOptions.md)
- [ResultOptions](interfaces/ResultOptions.md)
- [SetDataOptions](interfaces/SetDataOptions.md)
- [TimeoutManager](interfaces/TimeoutManager.md)
## Type Aliases
- [Accessor](type-aliases/Accessor.md)
- [AnyDataTag](type-aliases/AnyDataTag.md)
- [CreateBaseMutationResult](type-aliases/CreateBaseMutationResult.md)
- [CreateBaseQueryOptions](type-aliases/CreateBaseQueryOptions.md)
- [CreateBaseQueryResult](type-aliases/CreateBaseQueryResult.md)
- [CreateInfiniteQueryOptions](type-aliases/CreateInfiniteQueryOptions.md)
- [CreateInfiniteQueryResult](type-aliases/CreateInfiniteQueryResult.md)
- [CreateMutateAsyncFunction](type-aliases/CreateMutateAsyncFunction.md)
- [CreateMutateFunction](type-aliases/CreateMutateFunction.md)
- [CreateMutationOptions](type-aliases/CreateMutationOptions.md)
- [CreateMutationResult](type-aliases/CreateMutationResult.md)
- [CreateQueryOptions](type-aliases/CreateQueryOptions.md)
- [CreateQueryResult](type-aliases/CreateQueryResult.md)
- [DataTag](type-aliases/DataTag.md)
- [dataTagErrorSymbol](type-aliases/dataTagErrorSymbol.md)
- [dataTagSymbol](type-aliases/dataTagSymbol.md)
- [DefaultedInfiniteQueryObserverOptions](type-aliases/DefaultedInfiniteQueryObserverOptions.md)
- [DefaultedQueryObserverOptions](type-aliases/DefaultedQueryObserverOptions.md)
- [DefaultError](type-aliases/DefaultError.md)
- [DefinedCreateBaseQueryResult](type-aliases/DefinedCreateBaseQueryResult.md)
- [DefinedCreateInfiniteQueryResult](type-aliases/DefinedCreateInfiniteQueryResult.md)
- [DefinedCreateQueryResult](type-aliases/DefinedCreateQueryResult.md)
- [DefinedInfiniteQueryObserverResult](type-aliases/DefinedInfiniteQueryObserverResult.md)
- [DefinedInitialDataInfiniteOptions](type-aliases/DefinedInitialDataInfiniteOptions.md)
- [DefinedInitialDataOptions](type-aliases/DefinedInitialDataOptions.md)
- [DefinedQueryObserverResult](type-aliases/DefinedQueryObserverResult.md)
- [DistributiveOmit](type-aliases/DistributiveOmit.md)
- [~~EnsureInfiniteQueryDataOptions~~](type-aliases/EnsureInfiniteQueryDataOptions.md)
- [~~FetchInfiniteQueryOptions~~](type-aliases/FetchInfiniteQueryOptions.md)
- [FetchStatus](type-aliases/FetchStatus.md)
- [GetNextPageParamFunction](type-aliases/GetNextPageParamFunction.md)
- [GetPreviousPageParamFunction](type-aliases/GetPreviousPageParamFunction.md)
- [HydrationBoundary](type-aliases/HydrationBoundary.md)
- [InferDataFromTag](type-aliases/InferDataFromTag.md)
- [InferErrorFromTag](type-aliases/InferErrorFromTag.md)
- [InfiniteQueryExecuteOptions](type-aliases/InfiniteQueryExecuteOptions.md)
- [InfiniteQueryObserverResult](type-aliases/InfiniteQueryObserverResult.md)
- [InitialDataFunction](type-aliases/InitialDataFunction.md)
- [ManagedTimerId](type-aliases/ManagedTimerId.md)
- [MutateFunction](type-aliases/MutateFunction.md)
- [MutateFunctionRest](type-aliases/MutateFunctionRest.md)
- [MutationCacheNotifyEvent](type-aliases/MutationCacheNotifyEvent.md)
- [MutationFunction](type-aliases/MutationFunction.md)
- [MutationFunctionContext](type-aliases/MutationFunctionContext.md)
- [MutationKey](type-aliases/MutationKey.md)
- [MutationMeta](type-aliases/MutationMeta.md)
- [MutationObserverResult](type-aliases/MutationObserverResult.md)
- [MutationScope](type-aliases/MutationScope.md)
- [MutationStateOptions](type-aliases/MutationStateOptions.md)
- [MutationStatus](type-aliases/MutationStatus.md)
- [MutationTypeFromResult](type-aliases/MutationTypeFromResult.md)
- [NetworkMode](type-aliases/NetworkMode.md)
- [NonUndefinedGuard](type-aliases/NonUndefinedGuard.md)
- [NotifyEventType](type-aliases/NotifyEventType.md)
- [NotifyOnChangeProps](type-aliases/NotifyOnChangeProps.md)
- [OmitKeyof](type-aliases/OmitKeyof.md)
- [Override](type-aliases/Override.md)
- [PlaceholderDataFunction](type-aliases/PlaceholderDataFunction.md)
- [QueriesOptions](type-aliases/QueriesOptions.md)
- [QueriesPlaceholderDataFunction](type-aliases/QueriesPlaceholderDataFunction.md)
- [QueriesResults](type-aliases/QueriesResults.md)
- [QueryBooleanOption](type-aliases/QueryBooleanOption.md)
- [QueryCacheNotifyEvent](type-aliases/QueryCacheNotifyEvent.md)
- [QueryClientProviderProps](type-aliases/QueryClientProviderProps.md)
- [QueryFunction](type-aliases/QueryFunction.md)
- [QueryFunctionContext](type-aliases/QueryFunctionContext.md)
- [QueryKey](type-aliases/QueryKey.md)
- [QueryKeyHashFunction](type-aliases/QueryKeyHashFunction.md)
- [QueryKeyWithDataTag](type-aliases/QueryKeyWithDataTag.md)
- [QueryMeta](type-aliases/QueryMeta.md)
- [QueryObserverResult](type-aliases/QueryObserverResult.md)
- [QueryPersister](type-aliases/QueryPersister.md)
- [QueryStatus](type-aliases/QueryStatus.md)
- [SkipToken](type-aliases/SkipToken.md)
- [StaleTime](type-aliases/StaleTime.md)
- [StaleTimeFunction](type-aliases/StaleTimeFunction.md)
- [ThrowOnError](type-aliases/ThrowOnError.md)
- [TimeoutCallback](type-aliases/TimeoutCallback.md)
- [TimeoutProvider](type-aliases/TimeoutProvider.md)
- [UndefinedInitialDataInfiniteOptions](type-aliases/UndefinedInitialDataInfiniteOptions.md)
- [UndefinedInitialDataOptions](type-aliases/UndefinedInitialDataOptions.md)
- [UnsetMarker](type-aliases/UnsetMarker.md)
- [Updater](type-aliases/Updater.md)
- [WithRequired](type-aliases/WithRequired.md)
## Variables
- [dataTagErrorSymbol](variables/dataTagErrorSymbol.md)
- [dataTagSymbol](variables/dataTagSymbol.md)
- [defaultScheduler](variables/defaultScheduler.md)
- [environmentManager](variables/environmentManager.md)
- [focusManager](variables/focusManager.md)
- [HydrationBoundary](variables/HydrationBoundary.md)
- [~~isServer~~](variables/isServer.md)
- [notifyManager](variables/notifyManager.md)
- [onlineManager](variables/onlineManager.md)
- [skipToken](variables/skipToken.md)
- [timeoutManager](variables/timeoutManager.md)
- [unsetMarker](variables/unsetMarker.md)
## Functions
- [createInfiniteQuery](functions/createInfiniteQuery.md)
- [createMutation](functions/createMutation.md)
- [createQueries](functions/createQueries.md)
- [createQuery](functions/createQuery.md)
- [defaultShouldDehydrateMutation](functions/defaultShouldDehydrateMutation.md)
- [defaultShouldDehydrateQuery](functions/defaultShouldDehydrateQuery.md)
- [dehydrate](functions/dehydrate.md)
- [dehydrateQuery](functions/dehydrateQuery.md)
- [experimental\_streamedQuery](functions/experimental_streamedQuery.md)
- [getIsRestoringContext](functions/getIsRestoringContext.md)
- [getQueryClientContext](functions/getQueryClientContext.md)
- [hashKey](functions/hashKey.md)
- [hydrate](functions/hydrate.md)
- [infiniteQueryOptions](functions/infiniteQueryOptions.md)
- [~~isCancelledError~~](functions/isCancelledError.md)
- [keepPreviousData](functions/keepPreviousData.md)
- [matchMutation](functions/matchMutation.md)
- [matchQuery](functions/matchQuery.md)
- [mutationOptions](functions/mutationOptions.md)
- [noop](functions/noop.md)
- [partialMatchKey](functions/partialMatchKey.md)
- [queryOptions](functions/queryOptions.md)
- [replaceEqualDeep](functions/replaceEqualDeep.md)
- [setIsRestoringContext](functions/setIsRestoringContext.md)
- [setQueryClientContext](functions/setQueryClientContext.md)
- [shouldThrowError](functions/shouldThrowError.md)
- [useHydrate](functions/useHydrate.md)
- [useIsFetching](functions/useIsFetching.md)
- [useIsMutating](functions/useIsMutating.md)
- [useIsRestoring](functions/useIsRestoring.md)
- [useMutationState](functions/useMutationState.md)
- [useQueryClient](functions/useQueryClient.md)
## References
### QueryClientProvider
Renames and re-exports [HydrationBoundary](variables/HydrationBoundary.md)

26
docs/framework/svelte/reference/interfaces/CancelOptions.md Normal file
View File

@@ -0,0 +1,26 @@
---
id: CancelOptions
title: CancelOptions
---
Defined in: [packages/query-core/src/types.ts:1521](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1521)
## Properties
### revert?
```ts
optional revert: boolean;
```
Defined in: [packages/query-core/src/types.ts:1522](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1522)
***
### silent?
```ts
optional silent: boolean;
```
Defined in: [packages/query-core/src/types.ts:1523](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1523)

84
docs/framework/svelte/reference/interfaces/DefaultOptions.md Normal file
View File

@@ -0,0 +1,84 @@
---
id: DefaultOptions
title: DefaultOptions
---
Defined in: [packages/query-core/src/types.ts:1507](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1507)
## Type Parameters
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### dehydrate?
```ts
optional dehydrate: DehydrateOptions;
```
Defined in: [packages/query-core/src/types.ts:1518](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1518)
Default options used when dehydrating the client's caches; see [DehydrateOptions](DehydrateOptions.md).
***
### hydrate?
```ts
optional hydrate: object;
```
Defined in: [packages/query-core/src/types.ts:1516](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1516)
Default options used when hydrating queries; see [HydrateOptions](HydrateOptions.md).
#### deserializeData?
```ts
optional deserializeData: TransformerFn;
```
Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`.
#### mutations?
```ts
optional mutations: MutationOptions<unknown, Error, unknown, unknown>;
```
Default options merged into every mutation restored from the dehydrated state.
#### queries?
```ts
optional queries: QueryOptions<unknown, Error, unknown, readonly unknown[], never>;
```
Default options merged into every query restored from the dehydrated state.
***
### mutations?
```ts
optional mutations: MutationObserverOptions<unknown, TError, unknown, unknown>;
```
Defined in: [packages/query-core/src/types.ts:1514](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1514)
Default options applied to every mutation, unless overridden per-mutation.
***
### queries?
```ts
optional queries: OmitKeyof<QueryObserverOptions<unknown, TError, unknown, unknown, readonly unknown[], never>, "queryKey" | "suspense", "strictly">;
```
Defined in: [packages/query-core/src/types.ts:1509](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1509)
Default options applied to every query, unless overridden per-query.

89
docs/framework/svelte/reference/interfaces/DehydrateOptions.md Normal file
View File

@@ -0,0 +1,89 @@
---
id: DehydrateOptions
title: DehydrateOptions
---
Defined in: [packages/query-core/src/hydration.ts:42](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L42)
Options for `dehydrate`, controlling which queries/mutations are included in the resulting `DehydratedState` and
how their data/errors are transformed before being serialized (e.g. for embedding in server-rendered markup).
## Properties
### serializeData?
```ts
optional serializeData: TransformerFn;
```
Defined in: [packages/query-core/src/hydration.ts:44](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L44)
Transforms a query's `data` before it is dehydrated. Useful for non-JSON-serializable data.
***
### shouldDehydrateMutation()?
```ts
optional shouldDehydrateMutation: (mutation) => boolean;
```
Defined in: [packages/query-core/src/hydration.ts:46](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L46)
Predicate to decide whether a given `Mutation` should be dehydrated. Defaults to `defaultShouldDehydrateMutation`.
#### Parameters
##### mutation
[`Mutation`](../classes/Mutation.md)
#### Returns
`boolean`
***
### shouldDehydrateQuery()?
```ts
optional shouldDehydrateQuery: (query) => boolean;
```
Defined in: [packages/query-core/src/hydration.ts:48](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L48)
Predicate to decide whether a given `Query` should be dehydrated. Defaults to `defaultShouldDehydrateQuery`.
#### Parameters
##### query
[`Query`](../classes/Query.md)
#### Returns
`boolean`
***
### shouldRedactErrors()?
```ts
optional shouldRedactErrors: (error) => boolean;
```
Defined in: [packages/query-core/src/hydration.ts:54](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L54)
Predicate to decide whether a query's error should be redacted before dehydration. Errors are redacted
(replaced with a generic `Error('redacted')`) unless this function is provided and returns `false` for the
given error, in which case the original error is kept.
#### Parameters
##### error
`unknown`
#### Returns
`boolean`

30
docs/framework/svelte/reference/interfaces/DehydratedState.md Normal file
View File

@@ -0,0 +1,30 @@
---
id: DehydratedState
title: DehydratedState
---
Defined in: [packages/query-core/src/hydration.ts:94](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L94)
A serializable snapshot of a `QueryClient`'s cache, as produced by `dehydrate` and consumed by `hydrate`. Typically
transported from server to client (e.g. embedded in server-rendered markup) to seed the client's cache with data
that has already been fetched, avoiding a redundant fetch on the client.
## Properties
### mutations
```ts
mutations: DehydratedMutation[];
```
Defined in: [packages/query-core/src/hydration.ts:95](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L95)
***
### queries
```ts
queries: DehydratedQuery[];
```
Defined in: [packages/query-core/src/hydration.ts:96](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L96)

350
docs/framework/svelte/reference/interfaces/EnsureQueryDataOptions.md Normal file
View File

@@ -0,0 +1,350 @@
---
id: EnsureQueryDataOptions
title: EnsureQueryDataOptions
---
Defined in: [packages/query-core/src/types.ts:614](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L614)
## Deprecated
## Extends
- [`FetchQueryOptions`](FetchQueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `never`
## Properties
### ~~gcTime?~~
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`gcTime`](FetchQueryOptions.md#gctime)
***
### ~~initialData?~~
```ts
optional initialData:
| TData
| InitialDataFunction<TData>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`initialData`](FetchQueryOptions.md#initialdata)
***
### ~~initialDataUpdatedAt?~~
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`initialDataUpdatedAt`](FetchQueryOptions.md#initialdataupdatedat)
***
### ~~initialPageParam?~~
```ts
optional initialPageParam: undefined;
```
Defined in: [packages/query-core/src/types.ts:605](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L605)
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`initialPageParam`](FetchQueryOptions.md#initialpageparam)
***
### ~~maxPages?~~
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`maxPages`](FetchQueryOptions.md#maxpages)
***
### ~~meta?~~
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`meta`](FetchQueryOptions.md#meta)
***
### ~~networkMode?~~
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`networkMode`](FetchQueryOptions.md#networkmode)
***
### ~~persister?~~
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`persister`](FetchQueryOptions.md#persister)
***
### ~~queryFn?~~
```ts
optional queryFn:
| typeof skipToken
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`queryFn`](FetchQueryOptions.md#queryfn)
***
### ~~queryHash?~~
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`queryHash`](FetchQueryOptions.md#queryhash)
***
### ~~queryKey~~
```ts
queryKey: TQueryKey & object;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`queryKey`](FetchQueryOptions.md#querykey)
***
### ~~queryKeyHashFn?~~
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`queryKeyHashFn`](FetchQueryOptions.md#querykeyhashfn)
***
### ~~retry?~~
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`retry`](FetchQueryOptions.md#retry)
***
### ~~retryDelay?~~
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`retryDelay`](FetchQueryOptions.md#retrydelay)
***
### ~~revalidateIfStale?~~
```ts
optional revalidateIfStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:627](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L627)
***
### ~~staleTime?~~
```ts
optional staleTime: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:610](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L610)
The time in milliseconds after data is considered stale.
If the data is fresh it will be returned from the cache.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`staleTime`](FetchQueryOptions.md#staletime)
***
### ~~structuralSharing?~~
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.
#### Inherited from
[`FetchQueryOptions`](FetchQueryOptions.md).[`structuralSharing`](FetchQueryOptions.md#structuralsharing)

46
docs/framework/svelte/reference/interfaces/FetchNextPageOptions.md Normal file
View File

@@ -0,0 +1,46 @@
---
id: FetchNextPageOptions
title: FetchNextPageOptions
---
Defined in: [packages/query-core/src/types.ts:737](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L737)
## Extends
- [`ResultOptions`](ResultOptions.md)
## Properties
### cancelRefetch?
```ts
optional cancelRefetch: boolean;
```
Defined in: [packages/query-core/src/types.ts:746](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L746)
If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,
whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
Defaults to `true`.
***
### throwOnError?
```ts
optional throwOnError: boolean;
```
Defined in: [packages/query-core/src/types.ts:701](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L701)
If set to `true`, the method throws if any of the underlying query refetch tasks fail.
Defaults to `false`, in which case failed refetches are swallowed and not surfaced to the
caller.
#### Inherited from
[`ResultOptions`](ResultOptions.md).[`throwOnError`](ResultOptions.md#throwonerror)

46
docs/framework/svelte/reference/interfaces/FetchPreviousPageOptions.md Normal file
View File

@@ -0,0 +1,46 @@
---
id: FetchPreviousPageOptions
title: FetchPreviousPageOptions
---
Defined in: [packages/query-core/src/types.ts:749](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L749)
## Extends
- [`ResultOptions`](ResultOptions.md)
## Properties
### cancelRefetch?
```ts
optional cancelRefetch: boolean;
```
Defined in: [packages/query-core/src/types.ts:758](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L758)
If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,
whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
Defaults to `true`.
***
### throwOnError?
```ts
optional throwOnError: boolean;
```
Defined in: [packages/query-core/src/types.ts:701](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L701)
If set to `true`, the method throws if any of the underlying query refetch tasks fail.
Defaults to `false`, in which case failed refetches are swallowed and not surfaced to the
caller.
#### Inherited from
[`ResultOptions`](ResultOptions.md).[`throwOnError`](ResultOptions.md#throwonerror)

364
docs/framework/svelte/reference/interfaces/FetchQueryOptions.md Normal file
View File

@@ -0,0 +1,364 @@
---
id: FetchQueryOptions
title: FetchQueryOptions
---
Defined in: [packages/query-core/src/types.ts:595](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L595)
## Deprecated
## Extends
- [`WithRequired`](../type-aliases/WithRequired.md)\<[`QueryOptions`](QueryOptions.md)\<`TQueryFnData`, `TError`, `TData`, `TQueryKey`, `TPageParam`\>, `"queryKey"`\>
## Extended by
- [`EnsureQueryDataOptions`](EnsureQueryDataOptions.md)
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `never`
## Properties
### ~~gcTime?~~
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
#### Inherited from
```ts
WithRequired.gcTime
```
***
### ~~initialData?~~
```ts
optional initialData:
| TData
| InitialDataFunction<TData>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
#### Inherited from
```ts
WithRequired.initialData
```
***
### ~~initialDataUpdatedAt?~~
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
#### Inherited from
```ts
WithRequired.initialDataUpdatedAt
```
***
### ~~initialPageParam?~~
```ts
optional initialPageParam: undefined;
```
Defined in: [packages/query-core/src/types.ts:605](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L605)
***
### ~~maxPages?~~
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
#### Inherited from
```ts
WithRequired.maxPages
```
***
### ~~meta?~~
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
#### Inherited from
```ts
WithRequired.meta
```
***
### ~~networkMode?~~
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
```ts
WithRequired.networkMode
```
***
### ~~persister?~~
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
#### Inherited from
```ts
WithRequired.persister
```
***
### ~~queryFn?~~
```ts
optional queryFn:
| typeof skipToken
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
#### Inherited from
```ts
WithRequired.queryFn
```
***
### ~~queryHash?~~
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
#### Inherited from
```ts
WithRequired.queryHash
```
***
### ~~queryKey~~
```ts
queryKey: TQueryKey & object;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
#### Inherited from
```ts
WithRequired.queryKey
```
***
### ~~queryKeyHashFn?~~
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
#### Inherited from
```ts
WithRequired.queryKeyHashFn
```
***
### ~~retry?~~
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
#### Inherited from
```ts
WithRequired.retry
```
***
### ~~retryDelay?~~
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
```ts
WithRequired.retryDelay
```
***
### ~~staleTime?~~
```ts
optional staleTime: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:610](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L610)
The time in milliseconds after data is considered stale.
If the data is fresh it will be returned from the cache.
***
### ~~structuralSharing?~~
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.
#### Inherited from
```ts
WithRequired.structuralSharing
```

237
docs/framework/svelte/reference/interfaces/FocusManager.md Normal file
View File

@@ -0,0 +1,237 @@
---
id: FocusManager
title: FocusManager
---
Defined in: [packages/query-core/src/focusManager.ts:14](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L14)
The `FocusManager` manages the focus state within TanStack Query.
It can be used to change the default event listeners or to manually change the focus state.
## Extends
- `Subscribable`\<`Listener`\>
## Properties
### listeners
```ts
protected listeners: Set<Listener>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
## Methods
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### isFocused()
```ts
isFocused(): boolean;
```
Defined in: [packages/query-core/src/focusManager.ts:128](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L128)
`isFocused` can be used to get the current focus state.
#### Returns
`boolean`
***
### onFocus()
```ts
onFocus(): void;
```
Defined in: [packages/query-core/src/focusManager.ts:118](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L118)
`onFocus` notifies all subscribed listeners with the current focus state.
#### Returns
`void`
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/focusManager.ts:39](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L39)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/focusManager.ts:45](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L45)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onUnsubscribe
```
***
### setEventListener()
```ts
setEventListener(setup): void;
```
Defined in: [packages/query-core/src/focusManager.ts:77](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L77)
`setEventListener` can be used to set a custom event listener that will
be used to determine the focus state. The provided `setup` function
receives a `setFocused` callback: call it with a `boolean` to manually
set the focus state, or with no arguments to re-evaluate the current
focus state and notify subscribers.
#### Parameters
##### setup
`SetupFn`
#### Returns
`void`
#### Example
```ts
import { focusManager } from '@tanstack/query-core'
focusManager.setEventListener((handleFocus) => {
const listener = () => handleFocus()
// Listen to visibilitychange
if (typeof window !== 'undefined' && window.addEventListener) {
window.addEventListener('visibilitychange', listener, false)
}
return () => {
// Be sure to unsubscribe if a new handler is set
window.removeEventListener('visibilitychange', listener)
}
})
```
***
### setFocused()
```ts
setFocused(focused?): void;
```
Defined in: [packages/query-core/src/focusManager.ts:107](https://github.com/TanStack/query/blob/main/packages/query-core/src/focusManager.ts#L107)
`setFocused` can be used to manually set the focus state. Set `undefined`
to fall back to the default focus check.
#### Parameters
##### focused?
`boolean`
#### Returns
`void`
#### Example
```ts
import { focusManager } from '@tanstack/query-core'
// Set focused
focusManager.setFocused(true)
// Set unfocused
focusManager.setFocused(false)
// Fallback to the default focus check
focusManager.setFocused(undefined)
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`Listener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

43
docs/framework/svelte/reference/interfaces/HydrateOptions.md Normal file
View File

@@ -0,0 +1,43 @@
---
id: HydrateOptions
title: HydrateOptions
---
Defined in: [packages/query-core/src/hydration.ts:61](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L61)
Options for `hydrate`, controlling the default options applied to queries/mutations restored from a
`DehydratedState`, and how to reverse any transformation applied by `DehydrateOptions.serializeData`.
## Properties
### defaultOptions?
```ts
optional defaultOptions: object;
```
Defined in: [packages/query-core/src/hydration.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/hydration.ts#L62)
#### deserializeData?
```ts
optional deserializeData: TransformerFn;
```
Transforms a query's `data` after it is read from the dehydrated state, reversing `serializeData`.
#### mutations?
```ts
optional mutations: MutationOptions<unknown, Error, unknown, unknown>;
```
Default options merged into every mutation restored from the dehydrated state.
#### queries?
```ts
optional queries: QueryOptions<unknown, Error, unknown, readonly unknown[], never>;
```
Default options merged into every query restored from the dehydrated state.

36
docs/framework/svelte/reference/interfaces/InfiniteData.md Normal file
View File

@@ -0,0 +1,36 @@
---
id: InfiniteData
title: InfiniteData
---
Defined in: [packages/query-core/src/types.ts:210](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L210)
## Type Parameters
### TData
`TData`
### TPageParam
`TPageParam` = `unknown`
## Properties
### pageParams
```ts
pageParams: TPageParam[];
```
Defined in: [packages/query-core/src/types.ts:212](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L212)
***
### pages
```ts
pages: TData[];
```
Defined in: [packages/query-core/src/types.ts:211](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L211)

577
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverBaseResult.md Normal file
View File

@@ -0,0 +1,577 @@
---
id: InfiniteQueryObserverBaseResult
title: InfiniteQueryObserverBaseResult
---
Defined in: [packages/query-core/src/types.ts:1001](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1001)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Extended by
- [`InfiniteQueryObserverPendingResult`](InfiniteQueryObserverPendingResult.md)
- [`InfiniteQueryObserverLoadingResult`](InfiniteQueryObserverLoadingResult.md)
- [`InfiniteQueryObserverLoadingErrorResult`](InfiniteQueryObserverLoadingErrorResult.md)
- [`InfiniteQueryObserverRefetchErrorResult`](InfiniteQueryObserverRefetchErrorResult.md)
- [`InfiniteQueryObserverSuccessResult`](InfiniteQueryObserverSuccessResult.md)
- [`InfiniteQueryObserverPlaceholderResult`](InfiniteQueryObserverPlaceholderResult.md)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData | undefined;
```
Defined in: [packages/query-core/src/types.ts:771](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L771)
The last successfully resolved data for the query.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: TError | null;
```
Defined in: [packages/query-core/src/types.ts:780](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L780)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: boolean;
```
Defined in: [packages/query-core/src/types.ts:804](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L804)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
***
### isFetchNextPageError
```ts
isFetchNextPageError: boolean;
```
Defined in: [packages/query-core/src/types.ts:1028](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1028)
Will be `true` if the query failed while fetching the next page.
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: boolean;
```
Defined in: [packages/query-core/src/types.ts:1036](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1036)
Will be `true` if the query failed while fetching the previous page.
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:823](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L823)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: boolean;
```
Defined in: [packages/query-core/src/types.ts:831](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L831)
Will be `true` if the query failed while fetching for the first time.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: boolean;
```
Defined in: [packages/query-core/src/types.ts:827](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L827)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: boolean;
```
Defined in: [packages/query-core/src/types.ts:845](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L845)
Will be `true` if the data shown is the placeholder data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: boolean;
```
Defined in: [packages/query-core/src/types.ts:849](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L849)
Will be `true` if the query failed while refetching.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: boolean;
```
Defined in: [packages/query-core/src/types.ts:863](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L863)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: QueryStatus;
```
Defined in: [packages/query-core/src/types.ts:881](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L881)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverLoadingErrorResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverLoadingErrorResult
title: InfiniteQueryObserverLoadingErrorResult
---
Defined in: [packages/query-core/src/types.ts:1078](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1078)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1082](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1082)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: TError;
```
Defined in: [packages/query-core/src/types.ts:1083](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1083)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: true;
```
Defined in: [packages/query-core/src/types.ts:1084](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1084)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1089](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1089)
Will be `true` if the query failed while fetching the next page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1090](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1090)
Will be `true` if the query failed while fetching the previous page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:1086](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1086)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: true;
```
Defined in: [packages/query-core/src/types.ts:1087](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1087)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1085](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1085)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:1092](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1092)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:1088](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1088)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1091](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1091)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "error";
```
Defined in: [packages/query-core/src/types.ts:1093](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1093)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverLoadingResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverLoadingResult
title: InfiniteQueryObserverLoadingResult
---
Defined in: [packages/query-core/src/types.ts:1060](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1060)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1064](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1064)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1065](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1065)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1066](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1066)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1071](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1071)
Will be `true` if the query failed while fetching the next page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1072](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1072)
Will be `true` if the query failed while fetching the previous page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: true;
```
Defined in: [packages/query-core/src/types.ts:1068](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1068)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:1069](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1069)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: true;
```
Defined in: [packages/query-core/src/types.ts:1067](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1067)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:1074](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1074)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:1070](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1070)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1073](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1073)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "pending";
```
Defined in: [packages/query-core/src/types.ts:1075](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1075)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

624
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverOptions.md Normal file
View File

@@ -0,0 +1,624 @@
---
id: InfiniteQueryObserverOptions
title: InfiniteQueryObserverOptions
---
Defined in: [packages/query-core/src/types.ts:539](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L539)
## Extends
- [`QueryObserverOptions`](QueryObserverOptions.md)\<`TQueryFnData`, `TError`, `TData`, [`InfiniteData`](InfiniteData.md)\<`TQueryFnData`, `TPageParam`\>, `TQueryKey`, `TPageParam`\>.[`InfiniteQueryPageParamsOptions`](InfiniteQueryPageParamsOptions.md)\<`TQueryFnData`, `TPageParam`\>
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `unknown`
## Properties
### enabled?
```ts
optional enabled: QueryBooleanOption<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:398](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L398)
Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
To refetch the query, use the `refetch` method returned from the `useQuery` instance.
Accepts a boolean or function that returns a boolean.
Defaults to `true`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`enabled`](QueryObserverOptions.md#enabled)
***
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`gcTime`](QueryObserverOptions.md#gctime)
***
### getNextPageParam
```ts
getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
```
Defined in: [packages/query-core/src/types.ts:365](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L365)
This function can be set to automatically get the next cursor for infinite queries.
The result will also be used to determine the value of `hasNextPage`.
#### Inherited from
[`InfiniteQueryPageParamsOptions`](InfiniteQueryPageParamsOptions.md).[`getNextPageParam`](InfiniteQueryPageParamsOptions.md#getnextpageparam)
***
### getPreviousPageParam?
```ts
optional getPreviousPageParam: GetPreviousPageParamFunction<TPageParam, TQueryFnData>;
```
Defined in: [packages/query-core/src/types.ts:360](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L360)
This function can be set to automatically get the previous cursor for infinite queries.
The result will also be used to determine the value of `hasPreviousPage`.
#### Inherited from
[`InfiniteQueryPageParamsOptions`](InfiniteQueryPageParamsOptions.md).[`getPreviousPageParam`](InfiniteQueryPageParamsOptions.md#getpreviouspageparam)
***
### initialData?
```ts
optional initialData:
| InfiniteData<TQueryFnData, TPageParam>
| InitialDataFunction<InfiniteData<TQueryFnData, TPageParam>>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`initialData`](QueryObserverOptions.md#initialdata)
***
### initialDataUpdatedAt?
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`initialDataUpdatedAt`](QueryObserverOptions.md#initialdataupdatedat)
***
### initialPageParam
```ts
initialPageParam: TPageParam;
```
Defined in: [packages/query-core/src/types.ts:349](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L349)
#### Inherited from
[`InfiniteQueryPageParamsOptions`](InfiniteQueryPageParamsOptions.md).[`initialPageParam`](InfiniteQueryPageParamsOptions.md#initialpageparam)
***
### maxPages?
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`maxPages`](QueryObserverOptions.md#maxpages)
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`meta`](QueryObserverOptions.md#meta)
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`networkMode`](QueryObserverOptions.md#networkmode)
***
### notifyOnChangeProps?
```ts
optional notifyOnChangeProps: NotifyOnChangeProps;
```
Defined in: [packages/query-core/src/types.ts:484](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L484)
If set, the component will only re-render if any of the listed properties change.
When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
When set to `'all'`, the component will re-render whenever a query is updated.
When set to a function, the function will be executed to compute the list of properties.
Defaults to `undefined`, in which case property access is tracked automatically, and the
component only re-renders when one of the tracked properties changes.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`notifyOnChangeProps`](QueryObserverOptions.md#notifyonchangeprops)
***
### persister?
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`persister`](QueryObserverOptions.md#persister)
***
### placeholderData?
```ts
optional placeholderData:
| InfiniteData<TQueryFnData, TPageParam>
| PlaceholderDataFunction<InfiniteData<TQueryFnData, TPageParam>, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:511](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L511)
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.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`placeholderData`](QueryObserverOptions.md#placeholderdata)
***
### queryFn?
```ts
optional queryFn:
| typeof skipToken
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`queryFn`](QueryObserverOptions.md#queryfn)
***
### queryHash?
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`queryHash`](QueryObserverOptions.md#queryhash)
***
### queryKey
```ts
queryKey: TQueryKey & object;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`queryKey`](QueryObserverOptions.md#querykey)
***
### queryKeyHashFn?
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`queryKeyHashFn`](QueryObserverOptions.md#querykeyhashfn)
***
### refetchInterval?
```ts
optional refetchInterval: number | false | (query) => number | false | undefined;
```
Defined in: [packages/query-core/src/types.ts:414](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L414)
If set to a number, the query will continuously refetch at this frequency in milliseconds.
If set to a function, the function will be executed with the latest data and query to compute a frequency
Defaults to `false`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`refetchInterval`](QueryObserverOptions.md#refetchinterval)
***
### refetchIntervalInBackground?
```ts
optional refetchIntervalInBackground: boolean;
```
Defined in: [packages/query-core/src/types.ts:425](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L425)
If set to `true`, the query will continue to refetch while their tab/window is in the background.
Defaults to `false`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`refetchIntervalInBackground`](QueryObserverOptions.md#refetchintervalinbackground)
***
### refetchOnMount?
```ts
optional refetchOnMount: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:462](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L462)
If set to `true`, the query will refetch on mount if the data is stale.
If set to `false`, will disable additional instances of a query to trigger background refetch.
If set to `'always'`, the query will always refetch on mount (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value
Defaults to `true`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`refetchOnMount`](QueryObserverOptions.md#refetchonmount)
***
### refetchOnReconnect?
```ts
optional refetchOnReconnect: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:448](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L448)
If set to `true`, the query will refetch on reconnect if the data is stale.
If set to `false`, the query will not refetch on reconnect.
If set to `'always'`, the query will always refetch on reconnect (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value.
Defaults to `true` unless `networkMode` is `'always'`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`refetchOnReconnect`](QueryObserverOptions.md#refetchonreconnect)
***
### refetchOnWindowFocus?
```ts
optional refetchOnWindowFocus: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:434](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L434)
If set to `true`, the query will refetch on window focus if the data is stale.
If set to `false`, the query will not refetch on window focus.
If set to `'always'`, the query will always refetch on window focus (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value.
Defaults to `true`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`refetchOnWindowFocus`](QueryObserverOptions.md#refetchonwindowfocus)
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`retry`](QueryObserverOptions.md#retry)
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`retryDelay`](QueryObserverOptions.md#retrydelay)
***
### retryOnMount?
```ts
optional retryOnMount: QueryBooleanOption<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:474](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L474)
If set to `false`, the query will not be retried on mount if it contains an error.
If set to a function, the function will be executed with the query to compute the value.
Defaults to `true`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`retryOnMount`](QueryObserverOptions.md#retryonmount)
***
### select()?
```ts
optional select: (data) => TData;
```
Defined in: [packages/query-core/src/types.ts:500](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L500)
This option can be used to transform or select a part of the data returned by the query function. It affects
the returned `data` value, but does not affect what gets stored in the query cache.
The `select` function will only run if `data` changed, or if the reference to the `select` function itself
changes. To optimize, memoize the function so its reference stays stable across calls.
#### Parameters
##### data
[`InfiniteData`](InfiniteData.md)
#### Returns
`TData`
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`select`](QueryObserverOptions.md#select)
***
### staleTime?
```ts
optional staleTime: StaleTimeFunction<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:407](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L407)
The time in milliseconds after data is considered stale.
If set to `Infinity`, the data will never be considered stale.
If set to `'static'`, the data will never be considered stale.
If set to a function, the function will be executed with the query to compute a `staleTime`.
Defaults to `0`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`staleTime`](QueryObserverOptions.md#staletime)
***
### structuralSharing?
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`structuralSharing`](QueryObserverOptions.md#structuralsharing)
***
### suspense?
```ts
optional suspense: boolean;
```
Defined in: [packages/query-core/src/types.ts:507](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L507)
If set to `true`, the query will suspend when `status === 'pending'`
and throw errors when `status === 'error'`.
Defaults to `false`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`suspense`](QueryObserverOptions.md#suspense)
***
### throwOnError?
```ts
optional throwOnError: ThrowOnError<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:493](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L493)
Whether errors should be thrown instead of setting the `error` property.
If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
If set to `false` and `suspense` is `false`, errors are returned as state.
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`).
Defaults to `false`.
#### Inherited from
[`QueryObserverOptions`](QueryObserverOptions.md).[`throwOnError`](QueryObserverOptions.md#throwonerror)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverPendingResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverPendingResult
title: InfiniteQueryObserverPendingResult
---
Defined in: [packages/query-core/src/types.ts:1043](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1043)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1047](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1047)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1048](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1048)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1049](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1049)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1053](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1053)
Will be `true` if the query failed while fetching the next page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1054](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1054)
Will be `true` if the query failed while fetching the previous page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:823](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L823)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:1051](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1051)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: true;
```
Defined in: [packages/query-core/src/types.ts:1050](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1050)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:1056](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1056)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:1052](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1052)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1055](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1055)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "pending";
```
Defined in: [packages/query-core/src/types.ts:1057](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1057)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverPlaceholderResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverPlaceholderResult
title: InfiniteQueryObserverPlaceholderResult
---
Defined in: [packages/query-core/src/types.ts:1130](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1130)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:1134](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1134)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1136](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1136)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1135](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1135)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1143](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1143)
Will be `true` if the query failed while fetching the next page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1144](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1144)
Will be `true` if the query failed while fetching the previous page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:1138](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1138)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:1139](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1139)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1137](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1137)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: true;
```
Defined in: [packages/query-core/src/types.ts:1142](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1142)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:1140](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1140)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: true;
```
Defined in: [packages/query-core/src/types.ts:1141](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1141)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "success";
```
Defined in: [packages/query-core/src/types.ts:1145](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1145)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverRefetchErrorResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverRefetchErrorResult
title: InfiniteQueryObserverRefetchErrorResult
---
Defined in: [packages/query-core/src/types.ts:1096](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1096)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:1100](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1100)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: TError;
```
Defined in: [packages/query-core/src/types.ts:1101](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1101)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: true;
```
Defined in: [packages/query-core/src/types.ts:1102](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1102)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: boolean;
```
Defined in: [packages/query-core/src/types.ts:1028](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1028)
Will be `true` if the query failed while fetching the next page.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: boolean;
```
Defined in: [packages/query-core/src/types.ts:1036](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1036)
Will be `true` if the query failed while fetching the previous page.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:1104](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1104)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:1105](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1105)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1103](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1103)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:1108](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1108)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: true;
```
Defined in: [packages/query-core/src/types.ts:1106](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1106)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1107](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1107)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "error";
```
Defined in: [packages/query-core/src/types.ts:1109](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1109)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

600
docs/framework/svelte/reference/interfaces/InfiniteQueryObserverSuccessResult.md Normal file
View File

@@ -0,0 +1,600 @@
---
id: InfiniteQueryObserverSuccessResult
title: InfiniteQueryObserverSuccessResult
---
Defined in: [packages/query-core/src/types.ts:1112](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1112)
## Extends
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:1116](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1116)
The last successfully resolved data for the query.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`data`](InfiniteQueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`dataUpdatedAt`](InfiniteQueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1117](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1117)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`error`](InfiniteQueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdateCount`](InfiniteQueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`errorUpdatedAt`](InfiniteQueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureCount`](InfiniteQueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`failureReason`](InfiniteQueryObserverBaseResult.md#failurereason)
***
### fetchNextPage()
```ts
fetchNextPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1008](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1008)
This function allows you to fetch the next "page" of results.
#### Parameters
##### options?
[`FetchNextPageOptions`](FetchNextPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchNextPage`](InfiniteQueryObserverBaseResult.md#fetchnextpage)
***
### fetchPreviousPage()
```ts
fetchPreviousPage: (options?) => Promise<InfiniteQueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:1014](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1014)
This function allows you to fetch the previous "page" of results.
#### Parameters
##### options?
[`FetchPreviousPageOptions`](FetchPreviousPageOptions.md)
#### Returns
`Promise`\<[`InfiniteQueryObserverResult`](../type-aliases/InfiniteQueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchPreviousPage`](InfiniteQueryObserverBaseResult.md#fetchpreviouspage)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`fetchStatus`](InfiniteQueryObserverBaseResult.md#fetchstatus)
***
### hasNextPage
```ts
hasNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1020](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1020)
Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasNextPage`](InfiniteQueryObserverBaseResult.md#hasnextpage)
***
### hasPreviousPage
```ts
hasPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1024](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1024)
Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`hasPreviousPage`](InfiniteQueryObserverBaseResult.md#haspreviouspage)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isEnabled`](InfiniteQueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1118](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1118)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isError`](InfiniteQueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetched`](InfiniteQueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchedAfterMount`](InfiniteQueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetching`](InfiniteQueryObserverBaseResult.md#isfetching)
***
### isFetchingNextPage
```ts
isFetchingNextPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1032](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1032)
Will be `true` while fetching the next page with `fetchNextPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingNextPage`](InfiniteQueryObserverBaseResult.md#isfetchingnextpage)
***
### isFetchingPreviousPage
```ts
isFetchingPreviousPage: boolean;
```
Defined in: [packages/query-core/src/types.ts:1040](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1040)
Will be `true` while fetching the previous page with `fetchPreviousPage`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchingPreviousPage`](InfiniteQueryObserverBaseResult.md#isfetchingpreviouspage)
***
### isFetchNextPageError
```ts
isFetchNextPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1123](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1123)
Will be `true` if the query failed while fetching the next page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchNextPageError`](InfiniteQueryObserverBaseResult.md#isfetchnextpageerror)
***
### isFetchPreviousPageError
```ts
isFetchPreviousPageError: false;
```
Defined in: [packages/query-core/src/types.ts:1124](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1124)
Will be `true` if the query failed while fetching the previous page.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isFetchPreviousPageError`](InfiniteQueryObserverBaseResult.md#isfetchpreviouspageerror)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isInitialLoading`](InfiniteQueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:1120](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1120)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoading`](InfiniteQueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:1121](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1121)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isLoadingError`](InfiniteQueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPaused`](InfiniteQueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1119](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1119)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPending`](InfiniteQueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:1126](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1126)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isPlaceholderData`](InfiniteQueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:1122](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1122)
Will be `true` if the query failed while refetching.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetchError`](InfiniteQueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isRefetching`](InfiniteQueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isStale`](InfiniteQueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: true;
```
Defined in: [packages/query-core/src/types.ts:1125](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1125)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`isSuccess`](InfiniteQueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`refetch`](InfiniteQueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "success";
```
Defined in: [packages/query-core/src/types.ts:1127](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1127)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md).[`status`](InfiniteQueryObserverBaseResult.md#status)

64
docs/framework/svelte/reference/interfaces/InfiniteQueryPageParamsOptions.md Normal file
View File

@@ -0,0 +1,64 @@
---
id: InfiniteQueryPageParamsOptions
title: InfiniteQueryPageParamsOptions
---
Defined in: [packages/query-core/src/types.ts:352](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L352)
## Extends
- [`InitialPageParam`](InitialPageParam.md)\<`TPageParam`\>
## Extended by
- [`InfiniteQueryObserverOptions`](InfiniteQueryObserverOptions.md)
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TPageParam
`TPageParam` = `unknown`
## Properties
### getNextPageParam
```ts
getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
```
Defined in: [packages/query-core/src/types.ts:365](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L365)
This function can be set to automatically get the next cursor for infinite queries.
The result will also be used to determine the value of `hasNextPage`.
***
### getPreviousPageParam?
```ts
optional getPreviousPageParam: GetPreviousPageParamFunction<TPageParam, TQueryFnData>;
```
Defined in: [packages/query-core/src/types.ts:360](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L360)
This function can be set to automatically get the previous cursor for infinite queries.
The result will also be used to determine the value of `hasPreviousPage`.
***
### initialPageParam
```ts
initialPageParam: TPageParam;
```
Defined in: [packages/query-core/src/types.ts:349](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L349)
#### Inherited from
[`InitialPageParam`](InitialPageParam.md).[`initialPageParam`](InitialPageParam.md#initialpageparam)

26
docs/framework/svelte/reference/interfaces/InitialPageParam.md Normal file
View File

@@ -0,0 +1,26 @@
---
id: InitialPageParam
title: InitialPageParam
---
Defined in: [packages/query-core/src/types.ts:348](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L348)
## Extended by
- [`InfiniteQueryPageParamsOptions`](InfiniteQueryPageParamsOptions.md)
## Type Parameters
### TPageParam
`TPageParam` = `unknown`
## Properties
### initialPageParam
```ts
initialPageParam: TPageParam;
```
Defined in: [packages/query-core/src/types.ts:349](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L349)

49
docs/framework/svelte/reference/interfaces/InvalidateOptions.md Normal file
View File

@@ -0,0 +1,49 @@
---
id: InvalidateOptions
title: InvalidateOptions
---
Defined in: [packages/query-core/src/types.ts:734](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L734)
## Extends
- [`RefetchOptions`](RefetchOptions.md)
## Properties
### cancelRefetch?
```ts
optional cancelRefetch: boolean;
```
Defined in: [packages/query-core/src/types.ts:712](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L712)
If set to `true`, a currently running request will be cancelled before a new request is made
If set to `false`, no refetch will be made if there is already a request running.
Defaults to `true`.
#### Inherited from
[`RefetchOptions`](RefetchOptions.md).[`cancelRefetch`](RefetchOptions.md#cancelrefetch)
***
### throwOnError?
```ts
optional throwOnError: boolean;
```
Defined in: [packages/query-core/src/types.ts:701](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L701)
If set to `true`, the method throws if any of the underlying query refetch tasks fail.
Defaults to `false`, in which case failed refetches are swallowed and not surfaced to the
caller.
#### Inherited from
[`RefetchOptions`](RefetchOptions.md).[`throwOnError`](RefetchOptions.md#throwonerror)

145
docs/framework/svelte/reference/interfaces/InvalidateQueryFilters.md Normal file
View File

@@ -0,0 +1,145 @@
---
id: InvalidateQueryFilters
title: InvalidateQueryFilters
---
Defined in: [packages/query-core/src/types.ts:715](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L715)
Filters used to select queries, for example in `queryClient.getQueriesData` or `queryClient.invalidateQueries`.
All provided filters must match; filters that are left unspecified are ignored.
## Extends
- [`QueryFilters`](QueryFilters.md)\<`TQueryKey`\>
## Type Parameters
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
## Properties
### exact?
```ts
optional exact: boolean;
```
Defined in: [packages/query-core/src/utils.ts:41](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L41)
Match query key exactly
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`exact`](QueryFilters.md#exact)
***
### fetchStatus?
```ts
optional fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/utils.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L57)
Include queries matching their fetchStatus
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`fetchStatus`](QueryFilters.md#fetchstatus)
***
### predicate()?
```ts
optional predicate: (query) => boolean;
```
Defined in: [packages/query-core/src/utils.ts:45](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L45)
Include queries matching this predicate function
#### Parameters
##### query
[`Query`](../classes/Query.md)
#### Returns
`boolean`
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`predicate`](QueryFilters.md#predicate)
***
### queryKey?
```ts
optional queryKey: TQueryKey | TuplePrefixes<TQueryKey>;
```
Defined in: [packages/query-core/src/utils.ts:49](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L49)
Include queries matching this query key
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`queryKey`](QueryFilters.md#querykey)
***
### refetchType?
```ts
optional refetchType: QueryTypeFilter | "none";
```
Defined in: [packages/query-core/src/types.ts:727](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L727)
Controls which of the matched (now-invalidated) queries are refetched in the background.
Defaults to `'active'`.
- `'active'`: only queries with at least one active observer are refetched.
- `'inactive'`: only queries with no active observer are refetched.
- `'all'`: every matched query is refetched, active or not.
- `'none'`: no query is refetched; matched queries are only marked as invalidated.
***
### stale?
```ts
optional stale: boolean;
```
Defined in: [packages/query-core/src/utils.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L53)
Include or exclude stale queries
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`stale`](QueryFilters.md#stale)
***
### type?
```ts
optional type: QueryTypeFilter;
```
Defined in: [packages/query-core/src/utils.ts:37](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L37)
Filter to active queries, inactive queries or all queries
Defaults to `'all'`.
#### Inherited from
[`QueryFilters`](QueryFilters.md).[`type`](QueryFilters.md#type)

124
docs/framework/svelte/reference/interfaces/MutateOptions.md Normal file
View File

@@ -0,0 +1,124 @@
---
id: MutateOptions
title: MutateOptions
---
Defined in: [packages/query-core/src/types.ts:1284](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1284)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### onError()?
```ts
optional onError: (error, variables, onMutateResult, context) => void;
```
Defined in: [packages/query-core/src/types.ts:1296](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1296)
#### Parameters
##### error
`TError`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`void`
***
### onSettled()?
```ts
optional onSettled: (data, error, variables, onMutateResult, context) => void;
```
Defined in: [packages/query-core/src/types.ts:1302](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1302)
#### Parameters
##### data
`TData` | `undefined`
##### error
`TError` | `null`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`void`
***
### onSuccess()?
```ts
optional onSuccess: (data, variables, onMutateResult, context) => void;
```
Defined in: [packages/query-core/src/types.ts:1290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1290)
#### Parameters
##### data
`TData`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`void`

161
docs/framework/svelte/reference/interfaces/MutationCacheConfig.md Normal file
View File

@@ -0,0 +1,161 @@
---
id: MutationCacheConfig
title: MutationCacheConfig
---
Defined in: [packages/query-core/src/mutationCache.ts:26](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L26)
Global callbacks that fire for every mutation handled by a `MutationCache`, regardless of which
component or observer triggered it. They differ from the `defaultOptions` provided to a
`QueryClient` in two ways: `defaultOptions` can be overridden by each mutation, while these
callbacks are always called, and `onMutate` here does not allow returning a result.
If a callback returns a promise, it will be awaited before the mutation continues.
## Properties
### onError()?
```ts
optional onError: (error, variables, onMutateResult, mutation, context) => unknown;
```
Defined in: [packages/query-core/src/mutationCache.ts:28](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L28)
Called when any mutation in the cache encounters an error.
#### Parameters
##### error
`Error`
##### variables
`unknown`
##### onMutateResult
`unknown`
##### mutation
[`Mutation`](../classes/Mutation.md)\<`unknown`, `unknown`, `unknown`\>
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### onMutate()?
```ts
optional onMutate: (variables, mutation, context) => unknown;
```
Defined in: [packages/query-core/src/mutationCache.ts:44](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L44)
Called before any mutation in the cache executes.
#### Parameters
##### variables
`unknown`
##### mutation
[`Mutation`](../classes/Mutation.md)\<`unknown`, `unknown`, `unknown`\>
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### onSettled()?
```ts
optional onSettled: (data, error, variables, onMutateResult, mutation, context) => unknown;
```
Defined in: [packages/query-core/src/mutationCache.ts:50](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L50)
Called when any mutation in the cache is settled, either successfully or with an error.
#### Parameters
##### data
`unknown`
##### error
`Error` | `null`
##### variables
`unknown`
##### onMutateResult
`unknown`
##### mutation
[`Mutation`](../classes/Mutation.md)\<`unknown`, `unknown`, `unknown`\>
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### onSuccess()?
```ts
optional onSuccess: (data, variables, onMutateResult, mutation, context) => unknown;
```
Defined in: [packages/query-core/src/mutationCache.ts:36](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutationCache.ts#L36)
Called when any mutation in the cache is successful.
#### Parameters
##### data
`unknown`
##### variables
`unknown`
##### onMutateResult
`unknown`
##### mutation
[`Mutation`](../classes/Mutation.md)\<`unknown`, `unknown`, `unknown`\>
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`

85
docs/framework/svelte/reference/interfaces/MutationFilters.md Normal file
View File

@@ -0,0 +1,85 @@
---
id: MutationFilters
title: MutationFilters
---
Defined in: [packages/query-core/src/utils.ts:64](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L64)
Filters used to select mutations, for example in `mutationCache.findAll` or `queryClient.isMutating`.
All provided filters must match; filters that are left unspecified are ignored.
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `unknown`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### exact?
```ts
optional exact: boolean;
```
Defined in: [packages/query-core/src/utils.ts:73](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L73)
Match mutation key exactly
***
### mutationKey?
```ts
optional mutationKey: readonly unknown[];
```
Defined in: [packages/query-core/src/utils.ts:83](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L83)
Include mutations matching this mutation key
***
### predicate()?
```ts
optional predicate: (mutation) => boolean;
```
Defined in: [packages/query-core/src/utils.ts:77](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L77)
Include mutations matching this predicate function
#### Parameters
##### mutation
[`Mutation`](../classes/Mutation.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
#### Returns
`boolean`
***
### status?
```ts
optional status: MutationStatus;
```
Defined in: [packages/query-core/src/utils.ts:87](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L87)
Filter by mutation status

291
docs/framework/svelte/reference/interfaces/MutationObserverBaseResult.md Normal file
View File

@@ -0,0 +1,291 @@
---
id: MutationObserverBaseResult
title: MutationObserverBaseResult
---
Defined in: [packages/query-core/src/types.ts:1335](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1335)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extends
- [`MutationState`](MutationState.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Extended by
- [`MutationObserverIdleResult`](MutationObserverIdleResult.md)
- [`MutationObserverLoadingResult`](MutationObserverLoadingResult.md)
- [`MutationObserverErrorResult`](MutationObserverErrorResult.md)
- [`MutationObserverSuccessResult`](MutationObserverSuccessResult.md)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
#### Inherited from
[`MutationState`](MutationState.md).[`context`](MutationState.md#context)
***
### data
```ts
data: TData | undefined;
```
Defined in: [packages/query-core/src/types.ts:1344](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1344)
The last successfully resolved data for the mutation.
#### Overrides
[`MutationState`](MutationState.md).[`data`](MutationState.md#data)
***
### error
```ts
error: TError | null;
```
Defined in: [packages/query-core/src/types.ts:1353](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1353)
The error object for the mutation, if an error was encountered.
- Defaults to `null`.
#### Overrides
[`MutationState`](MutationState.md).[`error`](MutationState.md#error)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
#### Inherited from
[`MutationState`](MutationState.md).[`failureCount`](MutationState.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
#### Inherited from
[`MutationState`](MutationState.md).[`failureReason`](MutationState.md#failurereason)
***
### isError
```ts
isError: boolean;
```
Defined in: [packages/query-core/src/types.ts:1358](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1358)
A boolean variable derived from `status`.
- `true` if the last mutation attempt resulted in an error.
***
### isIdle
```ts
isIdle: boolean;
```
Defined in: [packages/query-core/src/types.ts:1363](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1363)
A boolean variable derived from `status`.
- `true` if the mutation is in its initial state prior to executing.
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
#### Inherited from
[`MutationState`](MutationState.md).[`isPaused`](MutationState.md#ispaused)
***
### isPending
```ts
isPending: boolean;
```
Defined in: [packages/query-core/src/types.ts:1368](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1368)
A boolean variable derived from `status`.
- `true` if the mutation is currently executing.
***
### isSuccess
```ts
isSuccess: boolean;
```
Defined in: [packages/query-core/src/types.ts:1373](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1373)
A boolean variable derived from `status`.
- `true` if the last mutation attempt was successful.
***
### mutate
```ts
mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1393](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1393)
The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
#### Param
The variables object to pass to the `mutationFn`.
#### Param
This function will fire when the mutation is successful and will be passed the mutation's result.
#### Param
This function will fire if the mutation encounters an error and will be passed the error.
#### Param
This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
#### Remarks
- If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
- All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
***
### reset()
```ts
reset: () => void;
```
Defined in: [packages/query-core/src/types.ts:1397](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1397)
A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
#### Returns
`void`
***
### status
```ts
status: MutationStatus;
```
Defined in: [packages/query-core/src/types.ts:1382](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1382)
The status of the mutation.
- Will be:
- `idle` initial status prior to the mutation function executing.
- `pending` if the mutation is currently executing.
- `error` if the last mutation attempt resulted in an error.
- `success` if the last mutation attempt was successful.
#### Overrides
[`MutationState`](MutationState.md).[`status`](MutationState.md#status)
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
#### Inherited from
[`MutationState`](MutationState.md).[`submittedAt`](MutationState.md#submittedat)
***
### variables
```ts
variables: TVariables | undefined;
```
Defined in: [packages/query-core/src/types.ts:1348](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1348)
The variables object passed to the `mutationFn`.
#### Overrides
[`MutationState`](MutationState.md).[`variables`](MutationState.md#variables)

308
docs/framework/svelte/reference/interfaces/MutationObserverErrorResult.md Normal file
View File

@@ -0,0 +1,308 @@
---
id: MutationObserverErrorResult
title: MutationObserverErrorResult
---
Defined in: [packages/query-core/src/types.ts:1442](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1442)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extends
- [`MutationObserverBaseResult`](MutationObserverBaseResult.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`context`](MutationObserverBaseResult.md#context)
***
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1453](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1453)
The last successfully resolved data for the mutation.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`data`](MutationObserverBaseResult.md#data)
***
### error
```ts
error: TError;
```
Defined in: [packages/query-core/src/types.ts:1454](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1454)
The error object for the mutation, if an error was encountered.
- Defaults to `null`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`error`](MutationObserverBaseResult.md#error)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureCount`](MutationObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureReason`](MutationObserverBaseResult.md#failurereason)
***
### isError
```ts
isError: true;
```
Defined in: [packages/query-core/src/types.ts:1456](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1456)
A boolean variable derived from `status`.
- `true` if the last mutation attempt resulted in an error.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isError`](MutationObserverBaseResult.md#iserror)
***
### isIdle
```ts
isIdle: false;
```
Defined in: [packages/query-core/src/types.ts:1457](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1457)
A boolean variable derived from `status`.
- `true` if the mutation is in its initial state prior to executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isIdle`](MutationObserverBaseResult.md#isidle)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPaused`](MutationObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1458](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1458)
A boolean variable derived from `status`.
- `true` if the mutation is currently executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPending`](MutationObserverBaseResult.md#ispending)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1459](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1459)
A boolean variable derived from `status`.
- `true` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isSuccess`](MutationObserverBaseResult.md#issuccess)
***
### mutate
```ts
mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1393](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1393)
The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
#### Param
The variables object to pass to the `mutationFn`.
#### Param
This function will fire when the mutation is successful and will be passed the mutation's result.
#### Param
This function will fire if the mutation encounters an error and will be passed the error.
#### Param
This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
#### Remarks
- If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
- All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`mutate`](MutationObserverBaseResult.md#mutate)
***
### reset()
```ts
reset: () => void;
```
Defined in: [packages/query-core/src/types.ts:1397](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1397)
A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
#### Returns
`void`
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`reset`](MutationObserverBaseResult.md#reset)
***
### status
```ts
status: "error";
```
Defined in: [packages/query-core/src/types.ts:1460](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1460)
The status of the mutation.
- Will be:
- `idle` initial status prior to the mutation function executing.
- `pending` if the mutation is currently executing.
- `error` if the last mutation attempt resulted in an error.
- `success` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`status`](MutationObserverBaseResult.md#status)
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`submittedAt`](MutationObserverBaseResult.md#submittedat)
***
### variables
```ts
variables: TVariables;
```
Defined in: [packages/query-core/src/types.ts:1455](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1455)
The variables object passed to the `mutationFn`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`variables`](MutationObserverBaseResult.md#variables)

308
docs/framework/svelte/reference/interfaces/MutationObserverIdleResult.md Normal file
View File

@@ -0,0 +1,308 @@
---
id: MutationObserverIdleResult
title: MutationObserverIdleResult
---
Defined in: [packages/query-core/src/types.ts:1400](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1400)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extends
- [`MutationObserverBaseResult`](MutationObserverBaseResult.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`context`](MutationObserverBaseResult.md#context)
***
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1411](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1411)
The last successfully resolved data for the mutation.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`data`](MutationObserverBaseResult.md#data)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1413](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1413)
The error object for the mutation, if an error was encountered.
- Defaults to `null`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`error`](MutationObserverBaseResult.md#error)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureCount`](MutationObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureReason`](MutationObserverBaseResult.md#failurereason)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1414](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1414)
A boolean variable derived from `status`.
- `true` if the last mutation attempt resulted in an error.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isError`](MutationObserverBaseResult.md#iserror)
***
### isIdle
```ts
isIdle: true;
```
Defined in: [packages/query-core/src/types.ts:1415](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1415)
A boolean variable derived from `status`.
- `true` if the mutation is in its initial state prior to executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isIdle`](MutationObserverBaseResult.md#isidle)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPaused`](MutationObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1416](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1416)
A boolean variable derived from `status`.
- `true` if the mutation is currently executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPending`](MutationObserverBaseResult.md#ispending)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1417](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1417)
A boolean variable derived from `status`.
- `true` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isSuccess`](MutationObserverBaseResult.md#issuccess)
***
### mutate
```ts
mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1393](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1393)
The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
#### Param
The variables object to pass to the `mutationFn`.
#### Param
This function will fire when the mutation is successful and will be passed the mutation's result.
#### Param
This function will fire if the mutation encounters an error and will be passed the error.
#### Param
This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
#### Remarks
- If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
- All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`mutate`](MutationObserverBaseResult.md#mutate)
***
### reset()
```ts
reset: () => void;
```
Defined in: [packages/query-core/src/types.ts:1397](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1397)
A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
#### Returns
`void`
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`reset`](MutationObserverBaseResult.md#reset)
***
### status
```ts
status: "idle";
```
Defined in: [packages/query-core/src/types.ts:1418](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1418)
The status of the mutation.
- Will be:
- `idle` initial status prior to the mutation function executing.
- `pending` if the mutation is currently executing.
- `error` if the last mutation attempt resulted in an error.
- `success` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`status`](MutationObserverBaseResult.md#status)
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`submittedAt`](MutationObserverBaseResult.md#submittedat)
***
### variables
```ts
variables: undefined;
```
Defined in: [packages/query-core/src/types.ts:1412](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1412)
The variables object passed to the `mutationFn`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`variables`](MutationObserverBaseResult.md#variables)

308
docs/framework/svelte/reference/interfaces/MutationObserverLoadingResult.md Normal file
View File

@@ -0,0 +1,308 @@
---
id: MutationObserverLoadingResult
title: MutationObserverLoadingResult
---
Defined in: [packages/query-core/src/types.ts:1421](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1421)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extends
- [`MutationObserverBaseResult`](MutationObserverBaseResult.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`context`](MutationObserverBaseResult.md#context)
***
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:1432](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1432)
The last successfully resolved data for the mutation.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`data`](MutationObserverBaseResult.md#data)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1434](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1434)
The error object for the mutation, if an error was encountered.
- Defaults to `null`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`error`](MutationObserverBaseResult.md#error)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureCount`](MutationObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureReason`](MutationObserverBaseResult.md#failurereason)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1435](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1435)
A boolean variable derived from `status`.
- `true` if the last mutation attempt resulted in an error.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isError`](MutationObserverBaseResult.md#iserror)
***
### isIdle
```ts
isIdle: false;
```
Defined in: [packages/query-core/src/types.ts:1436](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1436)
A boolean variable derived from `status`.
- `true` if the mutation is in its initial state prior to executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isIdle`](MutationObserverBaseResult.md#isidle)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPaused`](MutationObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: true;
```
Defined in: [packages/query-core/src/types.ts:1437](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1437)
A boolean variable derived from `status`.
- `true` if the mutation is currently executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPending`](MutationObserverBaseResult.md#ispending)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:1438](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1438)
A boolean variable derived from `status`.
- `true` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isSuccess`](MutationObserverBaseResult.md#issuccess)
***
### mutate
```ts
mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1393](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1393)
The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
#### Param
The variables object to pass to the `mutationFn`.
#### Param
This function will fire when the mutation is successful and will be passed the mutation's result.
#### Param
This function will fire if the mutation encounters an error and will be passed the error.
#### Param
This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
#### Remarks
- If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
- All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`mutate`](MutationObserverBaseResult.md#mutate)
***
### reset()
```ts
reset: () => void;
```
Defined in: [packages/query-core/src/types.ts:1397](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1397)
A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
#### Returns
`void`
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`reset`](MutationObserverBaseResult.md#reset)
***
### status
```ts
status: "pending";
```
Defined in: [packages/query-core/src/types.ts:1439](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1439)
The status of the mutation.
- Will be:
- `idle` initial status prior to the mutation function executing.
- `pending` if the mutation is currently executing.
- `error` if the last mutation attempt resulted in an error.
- `success` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`status`](MutationObserverBaseResult.md#status)
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`submittedAt`](MutationObserverBaseResult.md#submittedat)
***
### variables
```ts
variables: TVariables;
```
Defined in: [packages/query-core/src/types.ts:1433](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1433)
The variables object passed to the `mutationFn`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`variables`](MutationObserverBaseResult.md#variables)

322
docs/framework/svelte/reference/interfaces/MutationObserverOptions.md Normal file
View File

@@ -0,0 +1,322 @@
---
id: MutationObserverOptions
title: MutationObserverOptions
---
Defined in: [packages/query-core/src/types.ts:1267](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1267)
## Extends
- [`MutationOptions`](MutationOptions.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:1260](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1260)
The time in milliseconds that an unused/inactive mutation remains in memory before it is
garbage collected.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`gcTime`](MutationOptions.md#gctime)
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:1263](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1263)
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`meta`](MutationOptions.md#meta)
***
### mutationFn?
```ts
optional mutationFn: MutationFunction<TData, TVariables>;
```
Defined in: [packages/query-core/src/types.ts:1206](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1206)
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`mutationFn`](MutationOptions.md#mutationfn)
***
### mutationKey?
```ts
optional mutationKey: readonly unknown[];
```
Defined in: [packages/query-core/src/types.ts:1207](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1207)
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`mutationKey`](MutationOptions.md#mutationkey)
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:1253](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1253)
Controls whether a mutation is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`networkMode`](MutationOptions.md#networkmode)
***
### onError()?
```ts
optional onError: (error, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1218](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1218)
#### Parameters
##### error
`TError`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`onError`](MutationOptions.md#onerror)
***
### onMutate()?
```ts
optional onMutate: (variables, context) => TOnMutateResult | Promise<TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1208](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1208)
#### Parameters
##### variables
`TVariables`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`TOnMutateResult` \| `Promise`\<`TOnMutateResult`\>
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`onMutate`](MutationOptions.md#onmutate)
***
### onSettled()?
```ts
optional onSettled: (data, error, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1224](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1224)
#### Parameters
##### data
`TData` | `undefined`
##### error
`TError` | `null`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`onSettled`](MutationOptions.md#onsettled)
***
### onSuccess()?
```ts
optional onSuccess: (data, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1212](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1212)
#### Parameters
##### data
`TData`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`onSuccess`](MutationOptions.md#onsuccess)
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:1239](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1239)
If `false`, failed mutations will not retry by default.
If `true`, failed mutations will retry infinitely.
If set to an integer number, e.g. 3, failed mutations will retry until the failed mutation count meets that number.
If set to a function `(failureCount, error) => boolean` failed mutations will retry until the function returns false.
Defaults to `0`.
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`retry`](MutationOptions.md#retry)
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:1246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1246)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`retryDelay`](MutationOptions.md#retrydelay)
***
### scope?
```ts
optional scope: MutationScope;
```
Defined in: [packages/query-core/src/types.ts:1264](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1264)
#### Inherited from
[`MutationOptions`](MutationOptions.md).[`scope`](MutationOptions.md#scope)
***
### throwOnError?
```ts
optional throwOnError: boolean | (error) => boolean;
```
Defined in: [packages/query-core/src/types.ts:1281](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1281)
Whether errors should be thrown instead of setting the `error` property.
If set to `true`, all errors will be thrown to the nearest error boundary.
If set to a function, it will be passed the error and should return a boolean indicating whether to throw the
error (`true`) or return it as state (`false`).
Defaults to `false`.

308
docs/framework/svelte/reference/interfaces/MutationObserverSuccessResult.md Normal file
View File

@@ -0,0 +1,308 @@
---
id: MutationObserverSuccessResult
title: MutationObserverSuccessResult
---
Defined in: [packages/query-core/src/types.ts:1463](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1463)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extends
- [`MutationObserverBaseResult`](MutationObserverBaseResult.md)\<`TData`, `TError`, `TVariables`, `TOnMutateResult`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`context`](MutationObserverBaseResult.md#context)
***
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:1474](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1474)
The last successfully resolved data for the mutation.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`data`](MutationObserverBaseResult.md#data)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:1475](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1475)
The error object for the mutation, if an error was encountered.
- Defaults to `null`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`error`](MutationObserverBaseResult.md#error)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureCount`](MutationObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`failureReason`](MutationObserverBaseResult.md#failurereason)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:1477](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1477)
A boolean variable derived from `status`.
- `true` if the last mutation attempt resulted in an error.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isError`](MutationObserverBaseResult.md#iserror)
***
### isIdle
```ts
isIdle: false;
```
Defined in: [packages/query-core/src/types.ts:1478](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1478)
A boolean variable derived from `status`.
- `true` if the mutation is in its initial state prior to executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isIdle`](MutationObserverBaseResult.md#isidle)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPaused`](MutationObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:1479](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1479)
A boolean variable derived from `status`.
- `true` if the mutation is currently executing.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isPending`](MutationObserverBaseResult.md#ispending)
***
### isSuccess
```ts
isSuccess: true;
```
Defined in: [packages/query-core/src/types.ts:1480](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1480)
A boolean variable derived from `status`.
- `true` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`isSuccess`](MutationObserverBaseResult.md#issuccess)
***
### mutate
```ts
mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1393](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1393)
The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
#### Param
The variables object to pass to the `mutationFn`.
#### Param
This function will fire when the mutation is successful and will be passed the mutation's result.
#### Param
This function will fire if the mutation encounters an error and will be passed the error.
#### Param
This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
#### Remarks
- If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
- All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`mutate`](MutationObserverBaseResult.md#mutate)
***
### reset()
```ts
reset: () => void;
```
Defined in: [packages/query-core/src/types.ts:1397](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1397)
A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
#### Returns
`void`
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`reset`](MutationObserverBaseResult.md#reset)
***
### status
```ts
status: "success";
```
Defined in: [packages/query-core/src/types.ts:1481](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1481)
The status of the mutation.
- Will be:
- `idle` initial status prior to the mutation function executing.
- `pending` if the mutation is currently executing.
- `error` if the last mutation attempt resulted in an error.
- `success` if the last mutation attempt was successful.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`status`](MutationObserverBaseResult.md#status)
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
#### Inherited from
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`submittedAt`](MutationObserverBaseResult.md#submittedat)
***
### variables
```ts
variables: TVariables;
```
Defined in: [packages/query-core/src/types.ts:1476](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1476)
The variables object passed to the `mutationFn`.
#### Overrides
[`MutationObserverBaseResult`](MutationObserverBaseResult.md).[`variables`](MutationObserverBaseResult.md#variables)

257
docs/framework/svelte/reference/interfaces/MutationOptions.md Normal file
View File

@@ -0,0 +1,257 @@
---
id: MutationOptions
title: MutationOptions
---
Defined in: [packages/query-core/src/types.ts:1200](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1200)
## Extended by
- [`MutationObserverOptions`](MutationObserverOptions.md)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `void`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:1260](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1260)
The time in milliseconds that an unused/inactive mutation remains in memory before it is
garbage collected.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:1263](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1263)
***
### mutationFn?
```ts
optional mutationFn: MutationFunction<TData, TVariables>;
```
Defined in: [packages/query-core/src/types.ts:1206](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1206)
***
### mutationKey?
```ts
optional mutationKey: readonly unknown[];
```
Defined in: [packages/query-core/src/types.ts:1207](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1207)
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:1253](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1253)
Controls whether a mutation is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
***
### onError()?
```ts
optional onError: (error, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1218](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1218)
#### Parameters
##### error
`TError`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### onMutate()?
```ts
optional onMutate: (variables, context) => TOnMutateResult | Promise<TOnMutateResult>;
```
Defined in: [packages/query-core/src/types.ts:1208](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1208)
#### Parameters
##### variables
`TVariables`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`TOnMutateResult` \| `Promise`\<`TOnMutateResult`\>
***
### onSettled()?
```ts
optional onSettled: (data, error, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1224](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1224)
#### Parameters
##### data
`TData` | `undefined`
##### error
`TError` | `null`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult` | `undefined`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### onSuccess()?
```ts
optional onSuccess: (data, variables, onMutateResult, context) => unknown;
```
Defined in: [packages/query-core/src/types.ts:1212](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1212)
#### Parameters
##### data
`TData`
##### variables
`TVariables`
##### onMutateResult
`TOnMutateResult`
##### context
[`MutationFunctionContext`](../type-aliases/MutationFunctionContext.md)
#### Returns
`unknown`
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:1239](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1239)
If `false`, failed mutations will not retry by default.
If `true`, failed mutations will retry infinitely.
If set to an integer number, e.g. 3, failed mutations will retry until the failed mutation count meets that number.
If set to a function `(failureCount, error) => boolean` failed mutations will retry until the function returns false.
Defaults to `0`.
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:1246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1246)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
***
### scope?
```ts
optional scope: MutationScope;
```
Defined in: [packages/query-core/src/types.ts:1264](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1264)

142
docs/framework/svelte/reference/interfaces/MutationState.md Normal file
View File

@@ -0,0 +1,142 @@
---
id: MutationState
title: MutationState
---
Defined in: [packages/query-core/src/mutation.ts:30](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L30)
The raw state stored on a `Mutation` instance. This is the underlying state
that observer results (e.g. `MutationObserverResult`) are derived from.
## Extended by
- [`MutationObserverBaseResult`](MutationObserverBaseResult.md)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TVariables
`TVariables` = `unknown`
### TOnMutateResult
`TOnMutateResult` = `unknown`
## Properties
### context
```ts
context: TOnMutateResult | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:40](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L40)
The value returned by `onMutate`, if defined. Passed to `onSuccess`,
`onError` and `onSettled` as the mutation's context.
***
### data
```ts
data: TData | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:44](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L44)
The last successfully resolved data for the mutation.
***
### error
```ts
error: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:49](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L49)
The error object for the mutation, if the last attempt resulted in an error.
- Defaults to `null`.
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/mutation.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L53)
The number of times the mutation function has failed for the current attempt.
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/mutation.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L57)
The reason the current attempt failed, as reported by the retryer.
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/mutation.ts:62](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L62)
Whether the mutation is currently paused (see network mode), or is
waiting for another mutation with the same `scope` to finish.
***
### status
```ts
status: MutationStatus;
```
Defined in: [packages/query-core/src/mutation.ts:66](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L66)
The status of the mutation.
***
### submittedAt
```ts
submittedAt: number;
```
Defined in: [packages/query-core/src/mutation.ts:74](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L74)
The timestamp for when the mutation was submitted.
***
### variables
```ts
variables: TVariables | undefined;
```
Defined in: [packages/query-core/src/mutation.ts:70](https://github.com/TanStack/query/blob/main/packages/query-core/src/mutation.ts#L70)
The variables the mutation was last called with.

16
docs/framework/svelte/reference/interfaces/NotifyEvent.md Normal file
View File

@@ -0,0 +1,16 @@
---
id: NotifyEvent
title: NotifyEvent
---
Defined in: [packages/query-core/src/types.ts:1539](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1539)
## Properties
### type
```ts
type: NotifyEventType;
```
Defined in: [packages/query-core/src/types.ts:1540](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1540)

214
docs/framework/svelte/reference/interfaces/OnlineManager.md Normal file
View File

@@ -0,0 +1,214 @@
---
id: OnlineManager
title: OnlineManager
---
Defined in: [packages/query-core/src/onlineManager.ts:15](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L15)
The `OnlineManager` manages the online state within TanStack Query. It can
be used to change the default event listeners or to manually change the
online state.
By default, the `onlineManager` assumes an active network connection, and
listens to the `online` and `offline` events on the `window` object to
detect changes.
## Extends
- `Subscribable`\<`Listener`\>
## Properties
### listeners
```ts
protected listeners: Set<Listener>;
```
Defined in: [packages/query-core/src/subscribable.ts:2](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L2)
#### Inherited from
```ts
Subscribable.listeners
```
## Methods
### hasListeners()
```ts
hasListeners(): boolean;
```
Defined in: [packages/query-core/src/subscribable.ts:19](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L19)
#### Returns
`boolean`
#### Inherited from
```ts
Subscribable.hasListeners
```
***
### isOnline()
```ts
isOnline(): boolean;
```
Defined in: [packages/query-core/src/onlineManager.ts:109](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L109)
`isOnline` can be used to get the current online state.
#### Returns
`boolean`
***
### onSubscribe()
```ts
protected onSubscribe(): void;
```
Defined in: [packages/query-core/src/onlineManager.ts:44](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L44)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onSubscribe
```
***
### onUnsubscribe()
```ts
protected onUnsubscribe(): void;
```
Defined in: [packages/query-core/src/onlineManager.ts:50](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L50)
#### Returns
`void`
#### Overrides
```ts
Subscribable.onUnsubscribe
```
***
### setEventListener()
```ts
setEventListener(setup): void;
```
Defined in: [packages/query-core/src/onlineManager.ts:75](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L75)
`setEventListener` can be used to set a custom event listener that will
be used to determine the online state. The provided `setup` function
receives a `setOnline` callback that should be called with a `boolean`
whenever the online state changes.
#### Parameters
##### setup
`SetupFn`
#### Returns
`void`
#### Example
```ts
import NetInfo from '@react-native-community/netinfo'
import { onlineManager } from '@tanstack/query-core'
onlineManager.setEventListener((setOnline) => {
return NetInfo.addEventListener((state) => {
setOnline(!!state.isConnected)
})
})
```
***
### setOnline()
```ts
setOnline(online): void;
```
Defined in: [packages/query-core/src/onlineManager.ts:95](https://github.com/TanStack/query/blob/main/packages/query-core/src/onlineManager.ts#L95)
`setOnline` can be used to manually set the online state.
#### Parameters
##### online
`boolean`
#### Returns
`void`
#### Example
```ts
import { onlineManager } from '@tanstack/query-core'
// Set to online
onlineManager.setOnline(true)
// Set to offline
onlineManager.setOnline(false)
```
***
### subscribe()
```ts
subscribe(listener): () => void;
```
Defined in: [packages/query-core/src/subscribable.ts:8](https://github.com/TanStack/query/blob/main/packages/query-core/src/subscribable.ts#L8)
#### Parameters
##### listener
`Listener`
#### Returns
```ts
(): void;
```
##### Returns
`void`
#### Inherited from
```ts
Subscribable.subscribe
```

29
docs/framework/svelte/reference/interfaces/QueriesObserverOptions.md Normal file
View File

@@ -0,0 +1,29 @@
---
id: QueriesObserverOptions
title: QueriesObserverOptions
---
Defined in: [packages/query-core/src/queriesObserver.ts:23](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L23)
## Type Parameters
### TCombinedResult
`TCombinedResult` = [`QueryObserverResult`](../type-aliases/QueryObserverResult.md)[]
## Properties
### combine?
```ts
optional combine: CombineFn<TCombinedResult>;
```
Defined in: [packages/query-core/src/queriesObserver.ts:34](https://github.com/TanStack/query/blob/main/packages/query-core/src/queriesObserver.ts#L34)
A function that combines the array of `QueryObserverResult`s (one per
observed query) into a single value. The combined value is memoized and
only recomputed when one of the underlying results, the query hashes, or
the `combine` function itself changes.
Defaults to returning the array of `QueryObserverResult`s unchanged.

93
docs/framework/svelte/reference/interfaces/QueryCacheConfig.md Normal file
View File

@@ -0,0 +1,93 @@
---
id: QueryCacheConfig
title: QueryCacheConfig
---
Defined in: [packages/query-core/src/queryCache.ts:25](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L25)
Global callbacks that fire for every query handled by a `QueryCache`, regardless of which
component or observer triggered it. Unlike `QueryClient`'s `defaultOptions`, which a query can
override, these callbacks are always called. Unlike `MutationCacheConfig`'s callbacks, these
are fire-and-forget: their return value is not awaited before the query settles.
## Properties
### onError()?
```ts
optional onError: (error, query) => void;
```
Defined in: [packages/query-core/src/queryCache.ts:27](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L27)
Called when any query in the cache encounters an error.
#### Parameters
##### error
`Error`
##### query
[`Query`](../classes/Query.md)\<`unknown`, `unknown`, `unknown`\>
#### Returns
`void`
***
### onSettled()?
```ts
optional onSettled: (data, error, query) => void;
```
Defined in: [packages/query-core/src/queryCache.ts:34](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L34)
Called when any query in the cache is settled, either successfully or with an error.
#### Parameters
##### data
`unknown`
##### error
`Error` | `null`
##### query
[`Query`](../classes/Query.md)\<`unknown`, `unknown`, `unknown`\>
#### Returns
`void`
***
### onSuccess()?
```ts
optional onSuccess: (data, query) => void;
```
Defined in: [packages/query-core/src/queryCache.ts:32](https://github.com/TanStack/query/blob/main/packages/query-core/src/queryCache.ts#L32)
Called when any query in the cache is successful.
#### Parameters
##### data
`unknown`
##### query
[`Query`](../classes/Query.md)\<`unknown`, `unknown`, `unknown`\>
#### Returns
`void`

43
docs/framework/svelte/reference/interfaces/QueryClientConfig.md Normal file
View File

@@ -0,0 +1,43 @@
---
id: QueryClientConfig
title: QueryClientConfig
---
Defined in: [packages/query-core/src/types.ts:1495](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1495)
## Properties
### defaultOptions?
```ts
optional defaultOptions: DefaultOptions<Error>;
```
Defined in: [packages/query-core/src/types.ts:1504](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1504)
Default options for all queries and mutations created through this client.
***
### mutationCache?
```ts
optional mutationCache: MutationCache;
```
Defined in: [packages/query-core/src/types.ts:1502](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1502)
The mutation cache this client is connected to. A new `MutationCache` is created if not
provided.
***
### queryCache?
```ts
optional queryCache: QueryCache;
```
Defined in: [packages/query-core/src/types.ts:1497](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L1497)
The query cache this client is connected to. A new `QueryCache` is created if not provided.

382
docs/framework/svelte/reference/interfaces/QueryExecuteOptions.md Normal file
View File

@@ -0,0 +1,382 @@
---
id: QueryExecuteOptions
title: QueryExecuteOptions
---
Defined in: [packages/query-core/src/types.ts:574](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L574)
## Extends
- [`WithRequired`](../type-aliases/WithRequired.md)\<[`QueryOptions`](QueryOptions.md)\<`TQueryFnData`, `TError`, `TQueryData`, `TQueryKey`, `TPageParam`\>, `"queryKey"`\>
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryData
`TQueryData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `never`
## Properties
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
#### Inherited from
```ts
WithRequired.gcTime
```
***
### initialData?
```ts
optional initialData:
| TQueryData
| InitialDataFunction<TQueryData>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
#### Inherited from
```ts
WithRequired.initialData
```
***
### initialDataUpdatedAt?
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
#### Inherited from
```ts
WithRequired.initialDataUpdatedAt
```
***
### initialPageParam?
```ts
optional initialPageParam: undefined;
```
Defined in: [packages/query-core/src/types.ts:585](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L585)
***
### maxPages?
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
#### Inherited from
```ts
WithRequired.maxPages
```
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
#### Inherited from
```ts
WithRequired.meta
```
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
```ts
WithRequired.networkMode
```
***
### persister?
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
#### Inherited from
```ts
WithRequired.persister
```
***
### queryFn?
```ts
optional queryFn:
| typeof skipToken
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
#### Inherited from
```ts
WithRequired.queryFn
```
***
### queryHash?
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
#### Inherited from
```ts
WithRequired.queryHash
```
***
### queryKey
```ts
queryKey: TQueryKey & object;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
#### Inherited from
```ts
WithRequired.queryKey
```
***
### queryKeyHashFn?
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
#### Inherited from
```ts
WithRequired.queryKeyHashFn
```
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
#### Inherited from
```ts
WithRequired.retry
```
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
```ts
WithRequired.retryDelay
```
***
### select()?
```ts
optional select: (data) => TData;
```
Defined in: [packages/query-core/src/types.ts:586](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L586)
#### Parameters
##### data
`TQueryData`
#### Returns
`TData`
***
### staleTime?
```ts
optional staleTime: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:591](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L591)
The time in milliseconds after data is considered stale.
If the data is fresh it will be returned from the cache.
***
### structuralSharing?
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.
#### Inherited from
```ts
WithRequired.structuralSharing
```

104
docs/framework/svelte/reference/interfaces/QueryFilters.md Normal file
View File

@@ -0,0 +1,104 @@
---
id: QueryFilters
title: QueryFilters
---
Defined in: [packages/query-core/src/utils.ts:31](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L31)
Filters used to select queries, for example in `queryClient.getQueriesData` or `queryClient.invalidateQueries`.
All provided filters must match; filters that are left unspecified are ignored.
## Extended by
- [`InvalidateQueryFilters`](InvalidateQueryFilters.md)
- [`RefetchQueryFilters`](RefetchQueryFilters.md)
## Type Parameters
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
## Properties
### exact?
```ts
optional exact: boolean;
```
Defined in: [packages/query-core/src/utils.ts:41](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L41)
Match query key exactly
***
### fetchStatus?
```ts
optional fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/utils.ts:57](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L57)
Include queries matching their fetchStatus
***
### predicate()?
```ts
optional predicate: (query) => boolean;
```
Defined in: [packages/query-core/src/utils.ts:45](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L45)
Include queries matching this predicate function
#### Parameters
##### query
[`Query`](../classes/Query.md)
#### Returns
`boolean`
***
### queryKey?
```ts
optional queryKey: TQueryKey | TuplePrefixes<TQueryKey>;
```
Defined in: [packages/query-core/src/utils.ts:49](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L49)
Include queries matching this query key
***
### stale?
```ts
optional stale: boolean;
```
Defined in: [packages/query-core/src/utils.ts:53](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L53)
Include or exclude stale queries
***
### type?
```ts
optional type: QueryTypeFilter;
```
Defined in: [packages/query-core/src/utils.ts:37](https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L37)
Filter to active queries, inactive queries or all queries
Defaults to `'all'`.

358
docs/framework/svelte/reference/interfaces/QueryObserverBaseResult.md Normal file
View File

@@ -0,0 +1,358 @@
---
id: QueryObserverBaseResult
title: QueryObserverBaseResult
---
Defined in: [packages/query-core/src/types.ts:764](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L764)
## Extended by
- [`QueryObserverPendingResult`](QueryObserverPendingResult.md)
- [`QueryObserverLoadingResult`](QueryObserverLoadingResult.md)
- [`QueryObserverLoadingErrorResult`](QueryObserverLoadingErrorResult.md)
- [`QueryObserverRefetchErrorResult`](QueryObserverRefetchErrorResult.md)
- [`QueryObserverSuccessResult`](QueryObserverSuccessResult.md)
- [`QueryObserverPlaceholderResult`](QueryObserverPlaceholderResult.md)
- [`InfiniteQueryObserverBaseResult`](InfiniteQueryObserverBaseResult.md)
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData | undefined;
```
Defined in: [packages/query-core/src/types.ts:771](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L771)
The last successfully resolved data for the query.
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
***
### error
```ts
error: TError | null;
```
Defined in: [packages/query-core/src/types.ts:780](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L780)
The error object for the query, if an error was thrown.
- Defaults to `null`.
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
***
### isError
```ts
isError: boolean;
```
Defined in: [packages/query-core/src/types.ts:804](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L804)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
***
### isLoading
```ts
isLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:823](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L823)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
***
### isLoadingError
```ts
isLoadingError: boolean;
```
Defined in: [packages/query-core/src/types.ts:831](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L831)
Will be `true` if the query failed while fetching for the first time.
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
***
### isPending
```ts
isPending: boolean;
```
Defined in: [packages/query-core/src/types.ts:827](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L827)
Will be `pending` if there's no cached data and no query attempt was finished yet.
***
### isPlaceholderData
```ts
isPlaceholderData: boolean;
```
Defined in: [packages/query-core/src/types.ts:845](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L845)
Will be `true` if the data shown is the placeholder data.
***
### isRefetchError
```ts
isRefetchError: boolean;
```
Defined in: [packages/query-core/src/types.ts:849](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L849)
Will be `true` if the query failed while refetching.
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
***
### isSuccess
```ts
isSuccess: boolean;
```
Defined in: [packages/query-core/src/types.ts:863](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L863)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
***
### status
```ts
status: QueryStatus;
```
Defined in: [packages/query-core/src/types.ts:881](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L881)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.

452
docs/framework/svelte/reference/interfaces/QueryObserverLoadingErrorResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverLoadingErrorResult
title: QueryObserverLoadingErrorResult
---
Defined in: [packages/query-core/src/types.ts:923](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L923)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:927](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L927)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: TError;
```
Defined in: [packages/query-core/src/types.ts:928](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L928)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: true;
```
Defined in: [packages/query-core/src/types.ts:929](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L929)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:931](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L931)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: true;
```
Defined in: [packages/query-core/src/types.ts:932](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L932)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:930](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L930)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:935](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L935)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:933](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L933)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:934](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L934)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "error";
```
Defined in: [packages/query-core/src/types.ts:936](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L936)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

452
docs/framework/svelte/reference/interfaces/QueryObserverLoadingResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverLoadingResult
title: QueryObserverLoadingResult
---
Defined in: [packages/query-core/src/types.ts:907](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L907)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:911](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L911)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:912](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L912)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:913](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L913)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: true;
```
Defined in: [packages/query-core/src/types.ts:915](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L915)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:916](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L916)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: true;
```
Defined in: [packages/query-core/src/types.ts:914](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L914)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:919](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L919)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:917](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L917)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:918](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L918)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "pending";
```
Defined in: [packages/query-core/src/types.ts:920](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L920)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

560
docs/framework/svelte/reference/interfaces/QueryObserverOptions.md Normal file
View File

@@ -0,0 +1,560 @@
---
id: QueryObserverOptions
title: QueryObserverOptions
---
Defined in: [packages/query-core/src/types.ts:380](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L380)
## Extends
- [`WithRequired`](../type-aliases/WithRequired.md)\<[`QueryOptions`](QueryOptions.md)\<`TQueryFnData`, `TError`, `TQueryData`, `TQueryKey`, `TPageParam`\>, `"queryKey"`\>
## Extended by
- [`InfiniteQueryObserverOptions`](InfiniteQueryObserverOptions.md)
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryData
`TQueryData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `never`
## Properties
### enabled?
```ts
optional enabled: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:398](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L398)
Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
To refetch the query, use the `refetch` method returned from the `useQuery` instance.
Accepts a boolean or function that returns a boolean.
Defaults to `true`.
***
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
#### Inherited from
```ts
WithRequired.gcTime
```
***
### initialData?
```ts
optional initialData:
| TQueryData
| InitialDataFunction<TQueryData>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
#### Inherited from
```ts
WithRequired.initialData
```
***
### initialDataUpdatedAt?
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
#### Inherited from
```ts
WithRequired.initialDataUpdatedAt
```
***
### maxPages?
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
#### Inherited from
```ts
WithRequired.maxPages
```
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
#### Inherited from
```ts
WithRequired.meta
```
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
```ts
WithRequired.networkMode
```
***
### notifyOnChangeProps?
```ts
optional notifyOnChangeProps: NotifyOnChangeProps;
```
Defined in: [packages/query-core/src/types.ts:484](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L484)
If set, the component will only re-render if any of the listed properties change.
When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
When set to `'all'`, the component will re-render whenever a query is updated.
When set to a function, the function will be executed to compute the list of properties.
Defaults to `undefined`, in which case property access is tracked automatically, and the
component only re-renders when one of the tracked properties changes.
***
### persister?
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
#### Inherited from
```ts
WithRequired.persister
```
***
### placeholderData?
```ts
optional placeholderData:
| NonFunctionGuard<TQueryData>
| PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:511](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L511)
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.
***
### queryFn?
```ts
optional queryFn:
| typeof skipToken
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
#### Inherited from
```ts
WithRequired.queryFn
```
***
### queryHash?
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
#### Inherited from
```ts
WithRequired.queryHash
```
***
### queryKey
```ts
queryKey: TQueryKey & object;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
#### Inherited from
```ts
WithRequired.queryKey
```
***
### queryKeyHashFn?
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
#### Inherited from
```ts
WithRequired.queryKeyHashFn
```
***
### refetchInterval?
```ts
optional refetchInterval: number | false | (query) => number | false | undefined;
```
Defined in: [packages/query-core/src/types.ts:414](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L414)
If set to a number, the query will continuously refetch at this frequency in milliseconds.
If set to a function, the function will be executed with the latest data and query to compute a frequency
Defaults to `false`.
***
### refetchIntervalInBackground?
```ts
optional refetchIntervalInBackground: boolean;
```
Defined in: [packages/query-core/src/types.ts:425](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L425)
If set to `true`, the query will continue to refetch while their tab/window is in the background.
Defaults to `false`.
***
### refetchOnMount?
```ts
optional refetchOnMount: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:462](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L462)
If set to `true`, the query will refetch on mount if the data is stale.
If set to `false`, will disable additional instances of a query to trigger background refetch.
If set to `'always'`, the query will always refetch on mount (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value
Defaults to `true`.
***
### refetchOnReconnect?
```ts
optional refetchOnReconnect: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:448](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L448)
If set to `true`, the query will refetch on reconnect if the data is stale.
If set to `false`, the query will not refetch on reconnect.
If set to `'always'`, the query will always refetch on reconnect (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value.
Defaults to `true` unless `networkMode` is `'always'`.
***
### refetchOnWindowFocus?
```ts
optional refetchOnWindowFocus: boolean | "always" | (query) => boolean | "always";
```
Defined in: [packages/query-core/src/types.ts:434](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L434)
If set to `true`, the query will refetch on window focus if the data is stale.
If set to `false`, the query will not refetch on window focus.
If set to `'always'`, the query will always refetch on window focus (except when `staleTime: 'static'` is used).
If set to a function, the function will be executed with the latest data and query to compute the value.
Defaults to `true`.
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
#### Inherited from
```ts
WithRequired.retry
```
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
#### Inherited from
```ts
WithRequired.retryDelay
```
***
### retryOnMount?
```ts
optional retryOnMount: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:474](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L474)
If set to `false`, the query will not be retried on mount if it contains an error.
If set to a function, the function will be executed with the query to compute the value.
Defaults to `true`.
***
### select()?
```ts
optional select: (data) => TData;
```
Defined in: [packages/query-core/src/types.ts:500](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L500)
This option can be used to transform or select a part of the data returned by the query function. It affects
the returned `data` value, but does not affect what gets stored in the query cache.
The `select` function will only run if `data` changed, or if the reference to the `select` function itself
changes. To optimize, memoize the function so its reference stays stable across calls.
#### Parameters
##### data
`TQueryData`
#### Returns
`TData`
***
### staleTime?
```ts
optional staleTime: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:407](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L407)
The time in milliseconds after data is considered stale.
If set to `Infinity`, the data will never be considered stale.
If set to `'static'`, the data will never be considered stale.
If set to a function, the function will be executed with the query to compute a `staleTime`.
Defaults to `0`.
***
### structuralSharing?
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.
#### Inherited from
```ts
WithRequired.structuralSharing
```
***
### suspense?
```ts
optional suspense: boolean;
```
Defined in: [packages/query-core/src/types.ts:507](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L507)
If set to `true`, the query will suspend when `status === 'pending'`
and throw errors when `status === 'error'`.
Defaults to `false`.
***
### throwOnError?
```ts
optional throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:493](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L493)
Whether errors should be thrown instead of setting the `error` property.
If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
If set to `false` and `suspense` is `false`, errors are returned as state.
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`).
Defaults to `false`.

452
docs/framework/svelte/reference/interfaces/QueryObserverPendingResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverPendingResult
title: QueryObserverPendingResult
---
Defined in: [packages/query-core/src/types.ts:892](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L892)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: undefined;
```
Defined in: [packages/query-core/src/types.ts:896](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L896)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:897](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L897)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:898](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L898)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:823](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L823)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:900](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L900)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: true;
```
Defined in: [packages/query-core/src/types.ts:899](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L899)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:903](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L903)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:901](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L901)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:902](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L902)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "pending";
```
Defined in: [packages/query-core/src/types.ts:904](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L904)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

452
docs/framework/svelte/reference/interfaces/QueryObserverPlaceholderResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverPlaceholderResult
title: QueryObserverPlaceholderResult
---
Defined in: [packages/query-core/src/types.ts:971](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L971)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:975](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L975)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:977](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L977)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:976](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L976)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:979](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L979)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:980](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L980)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:978](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L978)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: true;
```
Defined in: [packages/query-core/src/types.ts:983](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L983)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:981](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L981)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: true;
```
Defined in: [packages/query-core/src/types.ts:982](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L982)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "success";
```
Defined in: [packages/query-core/src/types.ts:984](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L984)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

452
docs/framework/svelte/reference/interfaces/QueryObserverRefetchErrorResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverRefetchErrorResult
title: QueryObserverRefetchErrorResult
---
Defined in: [packages/query-core/src/types.ts:939](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L939)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:943](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L943)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: TError;
```
Defined in: [packages/query-core/src/types.ts:944](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L944)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: true;
```
Defined in: [packages/query-core/src/types.ts:945](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L945)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:947](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L947)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:948](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L948)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:946](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L946)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:951](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L951)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: true;
```
Defined in: [packages/query-core/src/types.ts:949](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L949)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: false;
```
Defined in: [packages/query-core/src/types.ts:950](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L950)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "error";
```
Defined in: [packages/query-core/src/types.ts:952](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L952)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

452
docs/framework/svelte/reference/interfaces/QueryObserverSuccessResult.md Normal file
View File

@@ -0,0 +1,452 @@
---
id: QueryObserverSuccessResult
title: QueryObserverSuccessResult
---
Defined in: [packages/query-core/src/types.ts:955](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L955)
## Extends
- [`QueryObserverBaseResult`](QueryObserverBaseResult.md)\<`TData`, `TError`\>
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData;
```
Defined in: [packages/query-core/src/types.ts:959](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L959)
The last successfully resolved data for the query.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`data`](QueryObserverBaseResult.md#data)
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:775](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L775)
The timestamp for when the query most recently returned the `status` as `"success"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`dataUpdatedAt`](QueryObserverBaseResult.md#dataupdatedat)
***
### error
```ts
error: null;
```
Defined in: [packages/query-core/src/types.ts:960](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L960)
The error object for the query, if an error was thrown.
- Defaults to `null`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`error`](QueryObserverBaseResult.md#error)
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/types.ts:799](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L799)
The sum of all errors.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdateCount`](QueryObserverBaseResult.md#errorupdatecount)
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/types.ts:784](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L784)
The timestamp for when the query most recently returned the `status` as `"error"`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`errorUpdatedAt`](QueryObserverBaseResult.md#errorupdatedat)
***
### failureCount
```ts
failureCount: number;
```
Defined in: [packages/query-core/src/types.ts:790](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L790)
The failure count for the query.
- Incremented every time the query fails.
- Reset to `0` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureCount`](QueryObserverBaseResult.md#failurecount)
***
### failureReason
```ts
failureReason: TError | null;
```
Defined in: [packages/query-core/src/types.ts:795](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L795)
The failure reason for the query retry.
- Reset to `null` when the query succeeds.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`failureReason`](QueryObserverBaseResult.md#failurereason)
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/types.ts:889](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L889)
The fetch status of the query.
- `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
- `paused`: The query wanted to fetch, but has been `paused`.
- `idle`: The query is not fetching.
- See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`fetchStatus`](QueryObserverBaseResult.md#fetchstatus)
***
### isEnabled
```ts
isEnabled: boolean;
```
Defined in: [packages/query-core/src/types.ts:867](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L867)
`true` if this observer is enabled, `false` otherwise.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isEnabled`](QueryObserverBaseResult.md#isenabled)
***
### isError
```ts
isError: false;
```
Defined in: [packages/query-core/src/types.ts:961](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L961)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query attempt resulted in an error.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isError`](QueryObserverBaseResult.md#iserror)
***
### isFetched
```ts
isFetched: boolean;
```
Defined in: [packages/query-core/src/types.ts:808](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L808)
Will be `true` if the query has been fetched.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetched`](QueryObserverBaseResult.md#isfetched)
***
### isFetchedAfterMount
```ts
isFetchedAfterMount: boolean;
```
Defined in: [packages/query-core/src/types.ts:813](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L813)
Will be `true` if the query has been fetched after the component mounted.
- This property can be used to not show any previously cached data.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetchedAfterMount`](QueryObserverBaseResult.md#isfetchedaftermount)
***
### isFetching
```ts
isFetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:818](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L818)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isFetching`](QueryObserverBaseResult.md#isfetching)
***
### ~~isInitialLoading~~
```ts
isInitialLoading: boolean;
```
Defined in: [packages/query-core/src/types.ts:836](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L836)
#### Deprecated
`isInitialLoading` is being deprecated in favor of `isLoading`
and will be removed in the next major version.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isInitialLoading`](QueryObserverBaseResult.md#isinitialloading)
***
### isLoading
```ts
isLoading: false;
```
Defined in: [packages/query-core/src/types.ts:963](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L963)
Is `true` whenever the first fetch for a query is in-flight.
- Is the same as `isFetching && isPending`.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoading`](QueryObserverBaseResult.md#isloading)
***
### isLoadingError
```ts
isLoadingError: false;
```
Defined in: [packages/query-core/src/types.ts:964](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L964)
Will be `true` if the query failed while fetching for the first time.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isLoadingError`](QueryObserverBaseResult.md#isloadingerror)
***
### isPaused
```ts
isPaused: boolean;
```
Defined in: [packages/query-core/src/types.ts:841](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L841)
A derived boolean from the `fetchStatus` variable, provided for convenience.
- The query wanted to fetch, but has been `paused`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPaused`](QueryObserverBaseResult.md#ispaused)
***
### isPending
```ts
isPending: false;
```
Defined in: [packages/query-core/src/types.ts:962](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L962)
Will be `pending` if there's no cached data and no query attempt was finished yet.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPending`](QueryObserverBaseResult.md#ispending)
***
### isPlaceholderData
```ts
isPlaceholderData: false;
```
Defined in: [packages/query-core/src/types.ts:967](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L967)
Will be `true` if the data shown is the placeholder data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isPlaceholderData`](QueryObserverBaseResult.md#isplaceholderdata)
***
### isRefetchError
```ts
isRefetchError: false;
```
Defined in: [packages/query-core/src/types.ts:965](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L965)
Will be `true` if the query failed while refetching.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetchError`](QueryObserverBaseResult.md#isrefetcherror)
***
### isRefetching
```ts
isRefetching: boolean;
```
Defined in: [packages/query-core/src/types.ts:854](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L854)
Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
- Is the same as `isFetching && !isPending`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isRefetching`](QueryObserverBaseResult.md#isrefetching)
***
### isStale
```ts
isStale: boolean;
```
Defined in: [packages/query-core/src/types.ts:858](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L858)
Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isStale`](QueryObserverBaseResult.md#isstale)
***
### isSuccess
```ts
isSuccess: true;
```
Defined in: [packages/query-core/src/types.ts:966](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L966)
A derived boolean from the `status` variable, provided for convenience.
- `true` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`isSuccess`](QueryObserverBaseResult.md#issuccess)
***
### refetch()
```ts
refetch: (options?) => Promise<QueryObserverResult<TData, TError>>;
```
Defined in: [packages/query-core/src/types.ts:871](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L871)
A function to manually refetch the query.
#### Parameters
##### options?
[`RefetchOptions`](RefetchOptions.md)
#### Returns
`Promise`\<[`QueryObserverResult`](../type-aliases/QueryObserverResult.md)\<`TData`, `TError`\>\>
#### Inherited from
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`refetch`](QueryObserverBaseResult.md#refetch)
***
### status
```ts
status: "success";
```
Defined in: [packages/query-core/src/types.ts:968](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L968)
The status of the query.
- Will be:
- `pending` if there's no cached data and no query attempt was finished yet.
- `error` if the query attempt resulted in an error.
- `success` if the query has received a response with no errors and is ready to display its data.
#### Overrides
[`QueryObserverBaseResult`](QueryObserverBaseResult.md).[`status`](QueryObserverBaseResult.md#status)

247
docs/framework/svelte/reference/interfaces/QueryOptions.md Normal file
View File

@@ -0,0 +1,247 @@
---
id: QueryOptions
title: QueryOptions
---
Defined in: [packages/query-core/src/types.ts:231](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L231)
## Type Parameters
### TQueryFnData
`TQueryFnData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
### TData
`TData` = `TQueryFnData`
### TQueryKey
`TQueryKey` *extends* [`QueryKey`](../type-aliases/QueryKey.md) = [`QueryKey`](../type-aliases/QueryKey.md)
### TPageParam
`TPageParam` = `never`
## Properties
### gcTime?
```ts
optional gcTime: number;
```
Defined in: [packages/query-core/src/types.ts:277](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L277)
The time in milliseconds that unused/inactive cache data remains in memory.
When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
When different garbage collection times are specified, the longest one will be used.
Setting it to `Infinity` will disable garbage collection.
Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.
Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see
`timeoutManager.setTimeoutProvider` for a workaround.
***
### initialData?
```ts
optional initialData:
| TData
| InitialDataFunction<TData>;
```
Defined in: [packages/query-core/src/types.ts:317](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L317)
If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
created or cached yet).
If set to a function, the function will be called **once** during the shared/root query initialization, and be
expected to synchronously return the initial data.
Initial data is considered stale by default unless a `staleTime` has been set.
`initialData` **is persisted** to the cache.
***
### initialDataUpdatedAt?
```ts
optional initialDataUpdatedAt: number | () => number | undefined;
```
Defined in: [packages/query-core/src/types.ts:321](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L321)
If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.
***
### maxPages?
```ts
optional maxPages: number;
```
Defined in: [packages/query-core/src/types.ts:345](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L345)
Maximum number of pages to store in the data of an infinite query.
***
### meta?
```ts
optional meta: Record<string, unknown>;
```
Defined in: [packages/query-core/src/types.ts:341](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L341)
Additional payload to be stored on each query.
Use this property to pass information that can be used in other places.
***
### networkMode?
```ts
optional networkMode: NetworkMode;
```
Defined in: [packages/query-core/src/types.ts:265](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L265)
Controls whether a query is allowed to run based on the current network connectivity.
Defaults to `'online'`.
#### See
[Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
***
### persister?
```ts
optional persister: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>;
```
Defined in: [packages/query-core/src/types.ts:290](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L290)
This option can be used to persist the result of a query to an external storage, bypassing the need to actually
call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.
***
### queryFn?
```ts
optional queryFn:
| QueryFunction<TQueryFnData, TQueryKey, TPageParam>
| typeof skipToken;
```
Defined in: [packages/query-core/src/types.ts:285](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L285)
The function that the query will use to request data.
Required, unless a default query function has been set via `queryClient.setQueryDefaults` or
`queryClient.setDefaultOptions`.
Receives a [QueryFunctionContext](../type-aliases/QueryFunctionContext.md).
Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.
***
### queryHash?
```ts
optional queryHash: string;
```
Defined in: [packages/query-core/src/types.ts:295](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L295)
The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used
as the actual cache key internally.
***
### queryKey?
```ts
optional queryKey: TQueryKey;
```
Defined in: [packages/query-core/src/types.ts:304](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L304)
The query key to use for this query.
The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)
for more information.
The query will automatically update when this key changes (as long as `enabled` is not set to `false`).
***
### queryKeyHashFn?
```ts
optional queryKeyHashFn: QueryKeyHashFunction<TQueryKey>;
```
Defined in: [packages/query-core/src/types.ts:308](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L308)
If specified, this function is used to hash the `queryKey` to a string.
***
### retry?
```ts
optional retry: RetryValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:246](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L246)
If `false`, failed queries will not retry by default.
If `true`, failed queries will retry infinitely.
If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
Defaults to `3` on the client and `0` on the server.
***
### retryDelay?
```ts
optional retryDelay: RetryDelayValue<TError>;
```
Defined in: [packages/query-core/src/types.ts:258](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L258)
This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the
next attempt in milliseconds.
A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential
backoff.
A function like `attempt => attempt * 1000` applies linear backoff.
Defaults to a function that applies exponential backoff, capped at 30 seconds.
***
### structuralSharing?
```ts
optional structuralSharing: boolean | (oldData, newData) => unknown;
```
Defined in: [packages/query-core/src/types.ts:330](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L330)
Set this to `false` to disable structural sharing between query results.
Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
Defaults to `true`.

175
docs/framework/svelte/reference/interfaces/QueryState.md Normal file
View File

@@ -0,0 +1,175 @@
---
id: QueryState
title: QueryState
---
Defined in: [packages/query-core/src/query.ts:52](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L52)
The raw state stored on a `Query` instance. This is the underlying state
that observer results (e.g. `QueryObserverResult`) are derived from.
## Type Parameters
### TData
`TData` = `unknown`
### TError
`TError` = [`DefaultError`](../type-aliases/DefaultError.md)
## Properties
### data
```ts
data: TData | undefined;
```
Defined in: [packages/query-core/src/query.ts:56](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L56)
The last successfully resolved data for the query.
***
### dataUpdateCount
```ts
dataUpdateCount: number;
```
Defined in: [packages/query-core/src/query.ts:60](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L60)
The number of times the query has successfully resolved.
***
### dataUpdatedAt
```ts
dataUpdatedAt: number;
```
Defined in: [packages/query-core/src/query.ts:64](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L64)
The timestamp for when the query most recently returned the `status` as `"success"`.
***
### error
```ts
error: TError | null;
```
Defined in: [packages/query-core/src/query.ts:69](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L69)
The error object for the query, if the last attempt resulted in an error.
- Defaults to `null`.
***
### errorUpdateCount
```ts
errorUpdateCount: number;
```
Defined in: [packages/query-core/src/query.ts:73](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L73)
The sum of all errors, incremented every time the query resolves with an error.
***
### errorUpdatedAt
```ts
errorUpdatedAt: number;
```
Defined in: [packages/query-core/src/query.ts:77](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L77)
The timestamp for when the query most recently returned the `status` as `"error"`.
***
### fetchFailureCount
```ts
fetchFailureCount: number;
```
Defined in: [packages/query-core/src/query.ts:83](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L83)
The failure count for the current fetch.
- Incremented every time the fetch fails.
- Reset to `0` when the fetch succeeds.
***
### fetchFailureReason
```ts
fetchFailureReason: TError | null;
```
Defined in: [packages/query-core/src/query.ts:88](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L88)
The reason the current fetch failed, as reported by the retryer.
- Reset to `null` when the fetch succeeds.
***
### fetchMeta
```ts
fetchMeta: FetchMeta | null;
```
Defined in: [packages/query-core/src/query.ts:93](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L93)
Metadata passed to the currently in-flight (or most recent) fetch, e.g. the
`fetchMore` direction for infinite queries.
***
### fetchStatus
```ts
fetchStatus: FetchStatus;
```
Defined in: [packages/query-core/src/query.ts:112](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L112)
The fetch status of the query.
- `fetching`: the `queryFn` is currently executing.
- `paused`: a fetch wanted to run but has been paused (see network mode).
- `idle`: the query is not fetching.
***
### isInvalidated
```ts
isInvalidated: boolean;
```
Defined in: [packages/query-core/src/query.ts:98](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L98)
Whether the query has been marked as invalidated via `invalidate()`.
- Reset to `false` whenever the query resolves successfully.
***
### status
```ts
status: QueryStatus;
```
Defined in: [packages/query-core/src/query.ts:105](https://github.com/TanStack/query/blob/main/packages/query-core/src/query.ts#L105)
The status of the query.
- `pending` if there's no cached data and no attempt was finished yet.
- `error` if the last attempt resulted in an error.
- `success` if the query has data.

50
docs/framework/svelte/reference/interfaces/RefetchOptions.md Normal file
View File

@@ -0,0 +1,50 @@
---
id: RefetchOptions
title: RefetchOptions
---
Defined in: [packages/query-core/src/types.ts:704](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L704)
## Extends
- [`ResultOptions`](ResultOptions.md)
## Extended by
- [`InvalidateOptions`](InvalidateOptions.md)
- [`ResetOptions`](ResetOptions.md)
## Properties
### cancelRefetch?
```ts
optional cancelRefetch: boolean;
```
Defined in: [packages/query-core/src/types.ts:712](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L712)
If set to `true`, a currently running request will be cancelled before a new request is made
If set to `false`, no refetch will be made if there is already a request running.
Defaults to `true`.
***
### throwOnError?
```ts
optional throwOnError: boolean;
```
Defined in: [packages/query-core/src/types.ts:701](https://github.com/TanStack/query/blob/main/packages/query-core/src/types.ts#L701)
If set to `true`, the method throws if any of the underlying query refetch tasks fail.
Defaults to `false`, in which case failed refetches are swallowed and not surfaced to the
caller.
#### Inherited from
[`ResultOptions`](ResultOptions.md).[`throwOnError`](ResultOptions.md#throwonerror)

Some files were not shown because too many files have changed in this diff Show More