@tanstack/solid-query 6.0.0-rc.5 → 6.0.0-rc.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,922 +0,0 @@
1
- import type { Accessor } from 'solid-js';
2
- import { AnyDataTag } from '@tanstack/query-core';
3
- import { CancelledError } from '@tanstack/query-core';
4
- import { CancelOptions } from '@tanstack/query-core';
5
- import { Context } from 'solid-js';
6
- import { DataTag } from '@tanstack/query-core';
7
- import { dataTagErrorSymbol } from '@tanstack/query-core';
8
- import { dataTagSymbol } from '@tanstack/query-core';
9
- import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
10
- import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
11
- import { DefaultError } from '@tanstack/query-core';
12
- import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
13
- import { defaultScheduler } from '@tanstack/query-core';
14
- import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
15
- import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
16
- import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
17
- import { DefinedQueryObserverResult } from '@tanstack/query-core';
18
- import { dehydrate } from '@tanstack/query-core';
19
- import { DehydratedState } from '@tanstack/query-core';
20
- import { DehydrateOptions } from '@tanstack/query-core';
21
- import { DistributiveOmit } from '@tanstack/query-core';
22
- import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
23
- import { EnsureQueryDataOptions } from '@tanstack/query-core';
24
- import { environmentManager } from '@tanstack/query-core';
25
- import { experimental_streamedQuery } from '@tanstack/query-core';
26
- import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
27
- import { FetchNextPageOptions } from '@tanstack/query-core';
28
- import { FetchPreviousPageOptions } from '@tanstack/query-core';
29
- import { FetchQueryOptions } from '@tanstack/query-core';
30
- import { FetchStatus } from '@tanstack/query-core';
31
- import { focusManager } from '@tanstack/query-core';
32
- import { GetNextPageParamFunction } from '@tanstack/query-core';
33
- import { GetPreviousPageParamFunction } from '@tanstack/query-core';
34
- import { hashKey } from '@tanstack/query-core';
35
- import { hydrate } from '@tanstack/query-core';
36
- import { HydrateOptions } from '@tanstack/query-core';
37
- import { InferDataFromTag } from '@tanstack/query-core';
38
- import { InferErrorFromTag } from '@tanstack/query-core';
39
- import { InfiniteData } from '@tanstack/query-core';
40
- import { InfiniteQueryObserver } from '@tanstack/query-core';
41
- import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
42
- import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
43
- import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
44
- import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
45
- import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
46
- import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
47
- import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
48
- import { InfiniteQueryObserverResult } from '@tanstack/query-core';
49
- import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
50
- import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
51
- import { InitialDataFunction } from '@tanstack/query-core';
52
- import { InitialPageParam } from '@tanstack/query-core';
53
- import { InvalidateOptions } from '@tanstack/query-core';
54
- import { InvalidateQueryFilters } from '@tanstack/query-core';
55
- import { isCancelledError } from '@tanstack/query-core';
56
- import { isServer } from '@tanstack/query-core';
57
- import type { JSX } from '@solidjs/web';
58
- import { keepPreviousData } from '@tanstack/query-core';
59
- import { ManagedTimerId } from '@tanstack/query-core';
60
- import { matchMutation } from '@tanstack/query-core';
61
- import { matchQuery } from '@tanstack/query-core';
62
- import { MutateFunction } from '@tanstack/query-core';
63
- import { MutateOptions } from '@tanstack/query-core';
64
- import { Mutation } from '@tanstack/query-core';
65
- import { MutationCache } from '@tanstack/query-core';
66
- import { MutationCacheNotifyEvent } from '@tanstack/query-core';
67
- import { MutationFilters } from '@tanstack/query-core';
68
- import { MutationFunction } from '@tanstack/query-core';
69
- import { MutationFunctionContext } from '@tanstack/query-core';
70
- import { MutationKey } from '@tanstack/query-core';
71
- import { MutationMeta } from '@tanstack/query-core';
72
- import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
73
- import { MutationObserverBaseResult } from '@tanstack/query-core';
74
- import { MutationObserverErrorResult } from '@tanstack/query-core';
75
- import { MutationObserverIdleResult } from '@tanstack/query-core';
76
- import { MutationObserverLoadingResult } from '@tanstack/query-core';
77
- import { MutationObserverOptions } from '@tanstack/query-core';
78
- import { MutationObserverResult } from '@tanstack/query-core';
79
- import { MutationObserverSuccessResult } from '@tanstack/query-core';
80
- import { MutationScope } from '@tanstack/query-core';
81
- import { MutationState } from '@tanstack/query-core';
82
- import { MutationStatus } from '@tanstack/query-core';
83
- import { NetworkMode } from '@tanstack/query-core';
84
- import { NonUndefinedGuard } from '@tanstack/query-core';
85
- import { noop } from '@tanstack/query-core';
86
- import { NotifyEvent } from '@tanstack/query-core';
87
- import { NotifyEventType } from '@tanstack/query-core';
88
- import { notifyManager } from '@tanstack/query-core';
89
- import { NotifyOnChangeProps } from '@tanstack/query-core';
90
- import { OmitKeyof } from '@tanstack/query-core';
91
- import { onlineManager } from '@tanstack/query-core';
92
- import { Override } from '@tanstack/query-core';
93
- import { partialMatchKey } from '@tanstack/query-core';
94
- import { PlaceholderDataFunction } from '@tanstack/query-core';
95
- import { QueriesObserver } from '@tanstack/query-core';
96
- import { QueriesObserverOptions } from '@tanstack/query-core';
97
- import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
98
- import { Query } from '@tanstack/query-core';
99
- import { QueryBooleanOption } from '@tanstack/query-core';
100
- import { QueryCache } from '@tanstack/query-core';
101
- import { QueryCacheNotifyEvent } from '@tanstack/query-core';
102
- import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
103
- import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
104
- import { QueryFilters } from '@tanstack/query-core';
105
- import { QueryFunction } from '@tanstack/query-core';
106
- import { QueryFunctionContext } from '@tanstack/query-core';
107
- import { QueryKey } from '@tanstack/query-core';
108
- import { QueryKeyHashFunction } from '@tanstack/query-core';
109
- import { QueryMeta } from '@tanstack/query-core';
110
- import { QueryObserver } from '@tanstack/query-core';
111
- import { QueryObserverBaseResult } from '@tanstack/query-core';
112
- import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
113
- import { QueryObserverLoadingResult } from '@tanstack/query-core';
114
- import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
115
- import { QueryObserverPendingResult } from '@tanstack/query-core';
116
- import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
117
- import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
118
- import { QueryObserverResult } from '@tanstack/query-core';
119
- import { QueryObserverSuccessResult } from '@tanstack/query-core';
120
- import { QueryPersister } from '@tanstack/query-core';
121
- import { QueryState } from '@tanstack/query-core';
122
- import { QueryStatus } from '@tanstack/query-core';
123
- import { RefetchOptions } from '@tanstack/query-core';
124
- import { RefetchQueryFilters } from '@tanstack/query-core';
125
- import { Register } from '@tanstack/query-core';
126
- import { replaceEqualDeep } from '@tanstack/query-core';
127
- import { ResetOptions } from '@tanstack/query-core';
128
- import { ResultOptions } from '@tanstack/query-core';
129
- import { SetDataOptions } from '@tanstack/query-core';
130
- import { shouldThrowError } from '@tanstack/query-core';
131
- import { SkipToken } from '@tanstack/query-core';
132
- import { skipToken } from '@tanstack/query-core';
133
- import { StaleTime } from '@tanstack/query-core';
134
- import { StaleTimeFunction } from '@tanstack/query-core';
135
- import { ThrowOnError } from '@tanstack/query-core';
136
- import { TimeoutCallback } from '@tanstack/query-core';
137
- import { timeoutManager } from '@tanstack/query-core';
138
- import { TimeoutProvider } from '@tanstack/query-core';
139
- import { UnsetMarker } from '@tanstack/query-core';
140
- import { unsetMarker } from '@tanstack/query-core';
141
- import { Updater } from '@tanstack/query-core';
142
- import { WithRequired } from '@tanstack/query-core';
143
-
144
- export { AnyDataTag }
145
-
146
- /** Internal seam: everything the read layer builds, for hooks that extend
147
- * the base result (`useInfiniteQuery` pagers ride the same entry). */
148
- declare interface BaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey> {
149
- result: UseBaseQueryResult<TData, TError>;
150
- observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
151
- /** Version-tracked: reading it subscribes to this query's cache events. */
152
- query: () => Query<TQueryFnData, TError, TQueryData, TQueryKey>;
153
- defaultedOptions: Accessor<ReturnType<QueryClient['defaultQueryOptions']>>;
154
- isFetching: () => boolean;
155
- status: () => 'pending' | 'error' | 'success';
156
- }
157
-
158
- export { CancelledError }
159
-
160
- export { CancelOptions }
161
-
162
- /**
163
- * Shared reactive core for the cross-cache aggregate hooks — `useIsFetching`,
164
- * `useIsMutating`, `useMutationState` — which all reduce to "a value derived
165
- * from a whole cache, refreshed on its events". Two invariants live here so
166
- * each hook doesn't restate them:
167
- *
168
- * Dual write. Cache events can fire inside an action transaction
169
- * (`useMutation` rides core `action`; an onSuccess invalidation dispatches
170
- * refetches mid-action), where a plain signal write is held until settle —
171
- * the in-flight value would be invisible. An optimistic override alone fails
172
- * the other way: outside a transaction, overrides drop at batch end. So a
173
- * durable signal carries committed state and an optimistic node tracks it as
174
- * its base; in-transaction values surface through the override, and the held
175
- * durable write becomes the base when the settle lands.
176
- *
177
- * Hydration. A cross-cache aggregate is not tied to a single async source,
178
- * so it cannot ride the boundary contract per-query meta uses (suspend until
179
- * settled). Its contract is fixed by construction instead: a hydrating
180
- * client can only ever observe the empty value at claim time — its own
181
- * fetches are held inside the hydration window, channel-primed entries are
182
- * settled, and mutations do not transfer across SSR. So the server
183
- * serializes the empty value, and a hydrated mount latches there until its
184
- * window closes: the subscription and first sync run from an effect half,
185
- * deferred past hydration — the earliest globally-safe moment for a
186
- * cross-cache read to go live (on a streamed page, an already-hydrated
187
- * region's refetch can be in flight while this region is still claiming).
188
- *
189
- * Every node here is created on the server too, where it is never read or
190
- * written: hydration id assignment is positional, so both sides must create
191
- * the same reactive nodes or every id downstream shifts and the subtree
192
- * key-misses.
193
- */
194
- export declare function createCacheAggregate<T>(subscribe: (onEvent: () => void) => () => void, read: (prev: T) => T, empty: T): Accessor<T>;
195
-
196
- export { DataTag }
197
-
198
- export { dataTagErrorSymbol }
199
-
200
- export { dataTagSymbol }
201
-
202
- export { DefaultedInfiniteQueryObserverOptions }
203
-
204
- export { DefaultedQueryObserverOptions }
205
-
206
- export { DefaultError }
207
-
208
- declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
209
- queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
210
- }
211
- export { DefaultOptions }
212
- export { DefaultOptions as DefaultOptions_alias_1 }
213
-
214
- export { defaultScheduler }
215
-
216
- export { defaultShouldDehydrateMutation }
217
-
218
- export { defaultShouldDehydrateQuery }
219
-
220
- export { DefinedInfiniteQueryObserverResult }
221
-
222
- declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<InfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
223
- initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
224
- }>;
225
- export { DefinedInitialDataInfiniteOptions }
226
- export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
227
-
228
- declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<QueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
229
- initialData: TQueryFnData | (() => TQueryFnData);
230
- }>;
231
- export { DefinedInitialDataOptions }
232
- export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
233
-
234
- export { DefinedQueryObserverResult }
235
-
236
- declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = OmitIsInitialLoading<DefinedQueryObserverResult<TData, TError>>;
237
- export { DefinedUseBaseQueryResult }
238
- export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
239
-
240
- declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitIsInitialLoading<DefinedInfiniteQueryObserverResult<TData, TError>>;
241
- export { DefinedUseInfiniteQueryResult }
242
- export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
243
-
244
- declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
245
- export { DefinedUseQueryResult }
246
- export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
247
-
248
- export { dehydrate }
249
-
250
- export { DehydratedState }
251
-
252
- export { DehydrateOptions }
253
-
254
- /**
255
- * Waits for every fetch the client has in flight to settle, then
256
- * dehydrates. This is the extraction half of a single-flight collector:
257
- * after route data functions run for the mutation's target URL, loaders
258
- * commonly kick off prefetches without awaiting them — plain
259
- * `dehydrate()` would snapshot those mid-fetch and ship nothing.
260
- *
261
- * ```ts
262
- * registerFlightDataSource(FLIGHT_DATA_SOURCE, (event, outcome) =>
263
- * loadFlightTarget({
264
- * router,
265
- * event,
266
- * outcome,
267
- * collect: () => dehydrateSettled(queryClient),
268
- * }),
269
- * )
270
- * ```
271
- *
272
- * Settling is chased to quiescence — awaiting one batch of fetches can
273
- * dispatch more (dependent queries keyed off a first result) — so an
274
- * unconditionally self-refetching query would keep this pending; that's
275
- * an app bug mirrored, not guarded.
276
- */
277
- declare function dehydrateSettled(client: QueryClient, options?: DehydrateOptions): Promise<DehydratedState>;
278
- export { dehydrateSettled }
279
- export { dehydrateSettled as dehydrateSettled_alias_1 }
280
-
281
- export { DistributiveOmit }
282
-
283
- export { EnsureInfiniteQueryDataOptions }
284
-
285
- export { EnsureQueryDataOptions }
286
-
287
- export { environmentManager }
288
-
289
- export { experimental_streamedQuery }
290
-
291
- export { FetchInfiniteQueryOptions }
292
-
293
- export { FetchNextPageOptions }
294
-
295
- export { FetchPreviousPageOptions }
296
-
297
- export { FetchQueryOptions }
298
-
299
- export { FetchStatus }
300
-
301
- /**
302
- * The query cache's single-flight source id. Mutation responses can fold
303
- * fresh data for multiple caches at once (Solid's multi-source
304
- * single-flight protocol); this is the slice the query cache claims — the
305
- * provider subscribes its consumer under it, and server collectors
306
- * register under it to produce the data:
307
- *
308
- * ```ts
309
- * import { registerFlightDataSource } from '@solidjs/web/server-functions/server'
310
- * import { FLIGHT_DATA_SOURCE, dehydrate } from '@tanstack/solid-query'
311
- *
312
- * registerFlightDataSource(FLIGHT_DATA_SOURCE, async (event, outcome) => {
313
- * // rebuild the data for outcome.targetUrl into a QueryClient, then
314
- * return dehydrate(queryClient)
315
- * })
316
- * ```
317
- *
318
- * The slice's payload is a `DehydratedState`; the provider consumes it
319
- * with `hydrate()`, so every mounted query on those keys updates before
320
- * the mutation's promise resolves — no follow-up refetches.
321
- *
322
- * A mutation can additionally declare its invalidation SCOPE with
323
- * `X-Revalidate` keys (the `revalidate` option of Solid's `reload`/
324
- * `redirect`/`respond` response helpers). The payload covers the slice of
325
- * that scope the server could recompute; whatever a declared key matches
326
- * beyond it is swept client-side (see the consumer below). The transport
327
- * delivers a response carrying keys to the consumer whether or not the
328
- * collector contributed a slice — with no slice, the whole scope is swept.
329
- */
330
- declare const FLIGHT_DATA_SOURCE = "sq";
331
- export { FLIGHT_DATA_SOURCE }
332
- export { FLIGHT_DATA_SOURCE as FLIGHT_DATA_SOURCE_alias_1 }
333
-
334
- export { focusManager }
335
-
336
- export { GetNextPageParamFunction }
337
-
338
- declare type GetOptions<T> = T extends {
339
- queryFnData: infer TQueryFnData;
340
- error?: infer TError;
341
- data: infer TData;
342
- } ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
343
- queryFnData: infer TQueryFnData;
344
- error?: infer TError;
345
- } ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
346
- data: infer TData;
347
- error?: infer TError;
348
- } ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
349
- queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
350
- select?: (data: any) => infer TData;
351
- throwOnError?: ThrowOnError<any, infer TError, any, any>;
352
- } ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
353
-
354
- export { GetPreviousPageParamFunction }
355
-
356
- declare type GetResults<T> = T extends {
357
- queryFnData: any;
358
- error?: infer TError;
359
- data: infer TData;
360
- } ? UseQueryResult<TData, TError> : T extends {
361
- queryFnData: infer TQueryFnData;
362
- error?: infer TError;
363
- } ? UseQueryResult<TQueryFnData, TError> : T extends {
364
- data: infer TData;
365
- error?: infer TError;
366
- } ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
367
- queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
368
- select?: (data: any) => infer TData;
369
- throwOnError?: ThrowOnError<any, infer TError, any, any>;
370
- } ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
371
-
372
- export { hashKey }
373
-
374
- export { hydrate }
375
-
376
- export { HydrateOptions }
377
-
378
- /**
379
- * Namespace prefix for cache entries in Solid's hydration registry — the
380
- * registry is shared with positional node ids and other libraries'
381
- * content-addressed keys (Solid Router uses its own cache keys), so query
382
- * hashes get their own prefix.
383
- */
384
- export declare const HYDRATION_KEY_PREFIX = "sq:";
385
-
386
- export { InferDataFromTag }
387
-
388
- export { InferErrorFromTag }
389
-
390
- export { InfiniteData }
391
-
392
- export { InfiniteQueryObserver }
393
-
394
- export { InfiniteQueryObserverBaseResult }
395
-
396
- export { InfiniteQueryObserverLoadingErrorResult }
397
-
398
- export { InfiniteQueryObserverLoadingResult }
399
-
400
- declare type InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
401
- export { InfiniteQueryObserverOptions }
402
- export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
403
-
404
- export { InfiniteQueryObserverPendingResult }
405
-
406
- export { InfiniteQueryObserverPlaceholderResult }
407
-
408
- export { InfiniteQueryObserverRefetchErrorResult }
409
-
410
- export { InfiniteQueryObserverResult }
411
-
412
- export { InfiniteQueryObserverSuccessResult }
413
-
414
- declare interface InfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
415
- queryKey: TQueryKey;
416
- /**
417
- * Defer the SSR stream flush until this query resolves on the server —
418
- * see {@link UseBaseQueryOptions.deferStream}.
419
- */
420
- deferStream?: boolean;
421
- /**
422
- * Reconciliation key for the data store — see
423
- * {@link UseBaseQueryOptions.reconcile}. For infinite queries this keys
424
- * items within pages; pages themselves merge positionally.
425
- */
426
- reconcile?: string | ((item: NonNullable<any>) => any) | null;
427
- }
428
- export { InfiniteQueryOptions }
429
- export { InfiniteQueryOptions as InfiniteQueryOptions_alias_1 }
430
-
431
- declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
432
- queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
433
- };
434
-
435
- declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
436
- queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
437
- };
438
- export { infiniteQueryOptions }
439
- export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
440
-
441
- export { InfiniteQueryPageParamsOptions }
442
-
443
- export { InitialDataFunction }
444
-
445
- export { InitialPageParam }
446
-
447
- export { InvalidateOptions }
448
-
449
- export { InvalidateQueryFilters }
450
-
451
- export { isCancelledError }
452
-
453
- declare const IsRestoringContext: Context<Accessor<boolean>>;
454
- export { IsRestoringContext }
455
- export { IsRestoringContext as IsRestoringContext_alias_1 }
456
-
457
- export { isServer }
458
-
459
- export { keepPreviousData }
460
-
461
- export { ManagedTimerId }
462
-
463
- export { matchMutation }
464
-
465
- export { matchQuery }
466
-
467
- declare type MAXIMUM_DEPTH = 20;
468
-
469
- export { MutateFunction }
470
-
471
- export { MutateOptions }
472
-
473
- export { Mutation }
474
-
475
- export { MutationCache }
476
-
477
- export { MutationCacheNotifyEvent }
478
-
479
- export { MutationFilters }
480
-
481
- export { MutationFunction }
482
-
483
- export { MutationFunctionContext }
484
-
485
- export { MutationKey }
486
-
487
- export { MutationMeta }
488
-
489
- export { MutationObserver_2 as MutationObserver }
490
-
491
- export { MutationObserverBaseResult }
492
-
493
- export { MutationObserverErrorResult }
494
-
495
- export { MutationObserverIdleResult }
496
-
497
- export { MutationObserverLoadingResult }
498
-
499
- export { MutationObserverOptions }
500
-
501
- export { MutationObserverResult }
502
-
503
- export { MutationObserverSuccessResult }
504
-
505
- declare interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
506
- }
507
- export { MutationOptions }
508
- export { MutationOptions as MutationOptions_alias_1 }
509
-
510
- declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<MutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<MutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
511
-
512
- declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<MutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<MutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
513
- export { mutationOptions }
514
- export { mutationOptions as mutationOptions_alias_1 }
515
-
516
- export { MutationScope }
517
-
518
- export { MutationState }
519
-
520
- declare type MutationStateOptions<TResult = MutationState> = {
521
- filters?: MutationFilters;
522
- select?: (mutation: Mutation) => TResult;
523
- };
524
-
525
- export { MutationStatus }
526
-
527
- export { NetworkMode }
528
-
529
- export { NonUndefinedGuard }
530
-
531
- export { noop }
532
-
533
- export { NotifyEvent }
534
-
535
- export { NotifyEventType }
536
-
537
- export { notifyManager }
538
-
539
- export { NotifyOnChangeProps }
540
-
541
- /**
542
- * Distributes an `isInitialLoading` omit over result unions so status
543
- * discriminants survive (a plain Omit over a union collapses it).
544
- */
545
- declare type OmitIsInitialLoading<T> = T extends unknown ? OmitKeyof<T, 'isInitialLoading' & keyof T> : never;
546
-
547
- export { OmitKeyof }
548
-
549
- export { onlineManager }
550
-
551
- export { Override }
552
-
553
- export { partialMatchKey }
554
-
555
- export { PlaceholderDataFunction }
556
-
557
- export { QueriesObserver }
558
-
559
- export { QueriesObserverOptions }
560
-
561
- /**
562
- * QueriesOptions reducer recursively snapshots function arguments to infer/enforce type param
563
- */
564
- declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
565
- ...Tail
566
- ], [
567
- ...TResult,
568
- GetOptions<Head>
569
- ], [
570
- ...TDepth,
571
- 1
572
- ]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
573
-
574
- export { QueriesPlaceholderDataFunction }
575
-
576
- /**
577
- * QueriesResults reducer recursively maps type param to results
578
- */
579
- declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
580
- ...Tail
581
- ], [
582
- ...TResult,
583
- GetResults<Head>
584
- ], [
585
- ...TDepth,
586
- 1
587
- ]> : {
588
- [K in keyof T]: GetResults<T[K]>;
589
- };
590
-
591
- export { Query }
592
-
593
- export { QueryBooleanOption }
594
-
595
- export { QueryCache }
596
-
597
- export { QueryCacheNotifyEvent }
598
-
599
- declare class QueryClient extends QueryClient_2 {
600
- constructor(config?: QueryClientConfig);
601
- }
602
- export { QueryClient }
603
- export { QueryClient as QueryClient_alias_1 }
604
-
605
- declare interface QueryClientConfig extends QueryClientConfig_2 {
606
- defaultOptions?: DefaultOptions;
607
- }
608
- export { QueryClientConfig }
609
- export { QueryClientConfig as QueryClientConfig_alias_1 }
610
-
611
- declare const QueryClientContext: Context<(() => QueryClient) | null>;
612
- export { QueryClientContext }
613
- export { QueryClientContext as QueryClientContext_alias_1 }
614
-
615
- /**
616
- * Provides the QueryClient and manages its mount lifecycle. On the server
617
- * it also registers the cache serializer above; on the client, hooks prime
618
- * the cache from their hash-keyed registry entries themselves (see
619
- * `useBaseQuery`) and the provider subscribes the cache's single-flight
620
- * consumer: mutation responses carrying a `FLIGHT_DATA_SOURCE` slice (a
621
- * `DehydratedState` produced by a server collector registered under the
622
- * same id) hydrate this client before the mutation's promise resolves.
623
- * Subscribing is inert when no server collector exists — the server just
624
- * folds nothing — so it is unconditional. One consumer per source: with
625
- * nested providers, the innermost mounted one owns the slice.
626
- */
627
- declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
628
- export { QueryClientProvider }
629
- export { QueryClientProvider as QueryClientProvider_alias_1 }
630
-
631
- declare type QueryClientProviderProps = {
632
- client: QueryClient;
633
- children?: JSX.Element;
634
- };
635
- export { QueryClientProviderProps }
636
- export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }
637
-
638
- export { QueryFilters }
639
-
640
- export { QueryFunction }
641
-
642
- export { QueryFunctionContext }
643
-
644
- export { QueryKey }
645
-
646
- export { QueryKeyHashFunction }
647
-
648
- export { QueryMeta }
649
-
650
- export { QueryObserver }
651
-
652
- export { QueryObserverBaseResult }
653
-
654
- export { QueryObserverLoadingErrorResult }
655
-
656
- export { QueryObserverLoadingResult }
657
-
658
- /**
659
- * Core observer options pass through unchanged. The old adapter omitted
660
- * `structuralSharing` and replaced it with a store-level `reconcile`
661
- * option; with reads derived directly from cache state, core's
662
- * cache-level structural sharing is exactly what keeps the data memo
663
- * referentially stable, so it is exposed again and `reconcile` is gone.
664
- */
665
- declare type QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>;
666
- export { QueryObserverOptions }
667
- export { QueryObserverOptions as QueryObserverOptions_alias_1 }
668
-
669
- export { QueryObserverPendingResult }
670
-
671
- export { QueryObserverPlaceholderResult }
672
-
673
- export { QueryObserverRefetchErrorResult }
674
-
675
- export { QueryObserverResult }
676
-
677
- export { QueryObserverSuccessResult }
678
-
679
- declare interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
680
- }
681
- export { QueryOptions }
682
- export { QueryOptions as QueryOptions_alias_1 }
683
-
684
- declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
685
- queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
686
- };
687
-
688
- declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
689
- queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
690
- };
691
- export { queryOptions }
692
- export { queryOptions as queryOptions_alias_1 }
693
-
694
- export { QueryPersister }
695
-
696
- export { QueryState }
697
-
698
- export { QueryStatus }
699
-
700
- export { RefetchOptions }
701
-
702
- export { RefetchQueryFilters }
703
-
704
- export { Register }
705
-
706
- export { replaceEqualDeep }
707
-
708
- export { ResetOptions }
709
-
710
- export { ResultOptions }
711
-
712
- export { SetDataOptions }
713
-
714
- export { shouldThrowError }
715
-
716
- export { SkipToken }
717
-
718
- export { skipToken }
719
-
720
- declare type SkipTokenForUseQueries = symbol;
721
-
722
- export { StaleTime }
723
-
724
- export { StaleTimeFunction }
725
-
726
- export { ThrowOnError }
727
-
728
- export { TimeoutCallback }
729
-
730
- export { timeoutManager }
731
-
732
- export { TimeoutProvider }
733
-
734
- declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<InfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
735
- initialData?: undefined;
736
- }>;
737
- export { UndefinedInitialDataInfiniteOptions }
738
- export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
739
-
740
- declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<QueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
741
- initialData?: undefined;
742
- }>;
743
- export { UndefinedInitialDataOptions }
744
- export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }
745
-
746
- export { UnsetMarker }
747
-
748
- export { unsetMarker }
749
-
750
- export { Updater }
751
-
752
- declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<OmitKeyof<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, 'context'>, {
753
- mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
754
- }>;
755
- export { UseBaseMutationResult }
756
- export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
757
-
758
- export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): UseBaseQueryResult<TData, TError>;
759
-
760
- export declare function useBaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): BaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
761
-
762
- declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
763
- /**
764
- * Defer the SSR stream flush until this query resolves on the server,
765
- * instead of letting the surrounding `<Loading>` boundary render its
766
- * fallback into the HTML. Passed through to Solid's own per-computation
767
- * `deferStream` option; server-only, ignored on the client.
768
- */
769
- deferStream?: boolean;
770
- /**
771
- * Reconciliation key for the data store. `data` is served as a Solid
772
- * store projection: every landing (refetch, invalidation, placeholder
773
- * upgrade) reconciles into the existing proxy graph instead of replacing
774
- * it, so deep reads are fine-grained and item identity survives across
775
- * fetches. This sets the identity key for that reconciliation — a
776
- * property name, a key-extraction function, or `null` to merge
777
- * positionally. Defaults to `'id'`. Read once at creation.
778
- */
779
- reconcile?: string | ((item: NonNullable<any>) => any) | null;
780
- }
781
- export { UseBaseQueryOptions }
782
- export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
783
-
784
- /**
785
- * `data` is non-optional: it is a suspending async read. It never returns
786
- * `undefined` — a read either suspends into the nearest `<Loading>`
787
- * boundary (first fetch in flight, disabled, restoring), returns a value
788
- * (committed, placeholder, initial), or throws (`<Errored>` /
789
- * `throwOnError`). The v5 `TData | undefined` face existed because reads
790
- * could observe the pre-fetch gap; here that gap is suspension.
791
- */
792
- declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = Override<OmitKeyof<QueryObserverResult<TData, TError>, 'isInitialLoading'>, {
793
- data: TData;
794
- }>;
795
- export { UseBaseQueryResult }
796
- export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
797
-
798
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
799
-
800
- declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
801
- export { useInfiniteQuery }
802
- export { useInfiniteQuery as useInfiniteQuery_alias_1 }
803
-
804
- declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<InfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
805
- export { UseInfiniteQueryOptions }
806
- export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
807
-
808
- /** Non-optional `data` for the same reason as {@link UseBaseQueryResult}. */
809
- declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = Override<OmitKeyof<InfiniteQueryObserverResult<TData, TError>, 'isInitialLoading'>, {
810
- data: TData;
811
- }>;
812
- export { UseInfiniteQueryResult }
813
- export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
814
-
815
- declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
816
- export { useIsFetching }
817
- export { useIsFetching as useIsFetching_alias_1 }
818
-
819
- declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
820
- export { useIsMutating }
821
- export { useIsMutating as useIsMutating_alias_1 }
822
-
823
- declare const useIsRestoring: () => Accessor<boolean>;
824
- export { useIsRestoring }
825
- export { useIsRestoring as useIsRestoring_alias_1 }
826
-
827
- /**
828
- * One `mutate`, returning a safe-to-ignore promise: errors are also routed
829
- * into reactive state, and ignoring the promise never surfaces an
830
- * unhandled rejection. Call-site callbacks are gone — settle logic that
831
- * used to live in `mutate(vars, { onSuccess })` is linear code after
832
- * `await mutate(vars)` or a config-level callback.
833
- */
834
- declare type UseMutateFunction<TData = unknown, _TError = DefaultError, TVariables = void, _TOnMutateResult = unknown> = (variables: TVariables) => Promise<TData>;
835
- export { UseMutateFunction }
836
- export { UseMutateFunction as UseMutateFunction_alias_1 }
837
-
838
- /**
839
- * Mutations ride core `action`: each `mutate()` call is one transaction.
840
- *
841
- * - Transient flight state (`isPending`, in-flight `variables`) is a
842
- * `createOptimistic` overlay written at the top of the action — visible
843
- * immediately, dropped automatically when the transition settles. The
844
- * engine's revert-on-settle IS the submission state machine.
845
- * - `options.onMutate(variables)` runs inside the same window: it is the
846
- * place to apply the caller's own optimistic overlays
847
- * (`createOptimistic` / `createOptimisticStore` writes). No context
848
- * object, no rollback plumbing — reverting is the engine's job.
849
- * - The fetch itself goes through query-core:
850
- * `mutationCache.build().execute()` supplies retry/backoff, offline
851
- * pausing, scoped serial execution, and cache-level lifecycle callbacks.
852
- * No `MutationObserver` — the adapter reads the Mutation's state
853
- * directly where flight metadata (failureCount, isPaused) is needed.
854
- * - Options-level callbacks are stripped from the built mutation and
855
- * re-run *post-`yield`*, inside the transaction: an
856
- * `onSuccess → invalidateQueries` chain issues version bumps whose
857
- * refetches hold this very transition, so mutation success and fresh
858
- * query data land in one atomic paint (and a single-flight payload has
859
- * already primed the cache by the time `execute` resolves).
860
- * - One `mutate`, returning a safe-to-ignore promise: rejection is also
861
- * routed into reactive state, and a no-op catch keeps the ignored
862
- * branch from surfacing as an unhandled rejection. The
863
- * `mutate`/`mutateAsync` split existed for React's callback-vs-promise
864
- * error routing; it has no space here.
865
- */
866
- declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
867
- export { useMutation }
868
- export { useMutation as useMutation_alias_1 }
869
-
870
- declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<MutationOptions<TData, TError, TVariables, TOnMutateResult>>;
871
- export { UseMutationOptions }
872
- export { UseMutationOptions as UseMutationOptions_alias_1 }
873
-
874
- declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
875
- export { UseMutationResult }
876
- export { UseMutationResult as UseMutationResult_alias_1 }
877
-
878
- declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
879
- export { useMutationState }
880
- export { useMutationState as useMutationState_alias_1 }
881
-
882
- declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(queriesOptions: Accessor<{
883
- queries: readonly [...QueriesOptions<T>] | readonly [...{
884
- [K in keyof T]: GetOptions<T[K]>;
885
- }];
886
- combine?: (result: QueriesResults<T>) => TCombinedResult;
887
- }>, queryClient?: Accessor<QueryClient>): TCombinedResult;
888
- export { useQueries }
889
- export { useQueries as useQueries_alias_1 }
890
-
891
- declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
892
-
893
- declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
894
- export { useQuery }
895
- export { useQuery as useQuery_alias_1 }
896
-
897
- declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
898
- export { useQueryClient }
899
- export { useQueryClient as useQueryClient_alias_1 }
900
-
901
- declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<QueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
902
- export { UseQueryOptions }
903
- export { UseQueryOptions as UseQueryOptions_alias_1 }
904
-
905
- declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
906
- placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
907
- /**
908
- * @deprecated The `suspense` option has been removed. Suspense is the
909
- * model: each result's `data` is an async read that suspends into the
910
- * nearest `<Loading>` boundary while its first fetch is in flight, same
911
- * as `useQuery`. Setting `suspense` is a no-op.
912
- */
913
- suspense?: boolean;
914
- };
915
-
916
- declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
917
- export { UseQueryResult }
918
- export { UseQueryResult as UseQueryResult_alias_1 }
919
-
920
- export { WithRequired }
921
-
922
- export { }