@ethlete/query 6.0.0-next.51 → 6.0.0-next.53

package/types/ethlete-query.d.ts

@@ -2,11 +2,11 @@ import { CanMatchFn, CanActivateFn, UrlTree, Router, NavigationBehaviorOptions }
 import * as rxjs from 'rxjs';
 import { Observable, Subscribable, BehaviorSubject, Subject } from 'rxjs';
 import * as _angular_core from '@angular/core';
-import { DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, Signal, Injector, CreateEffectOptions, EnvironmentProviders, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy } from '@angular/core';
+import { DestroyRef, EnvironmentInjector, ErrorHandler, Signal, WritableSignal, Injector, CreateEffectOptions, EnvironmentProviders, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
 import { ProviderDefinition, RuntimeError } from '@ethlete/core';
 import * as _angular_common_http from '@angular/common/http';
-import { HttpClient, HttpErrorResponse, HttpHeaders, HttpEvent, HttpStatusCode } from '@angular/common/http';
+import { HttpClient, HttpErrorResponse, HttpHeaders, HttpEvent, HttpContextToken, HttpStatusCode } from '@angular/common/http';
 import * as _ethlete_query from '@ethlete/query';
 import { NormalizedPagination, ContentfulGqlLikePaginated, DynLikePaginated, Paginated, GgLikePaginated, FormViolationListView, FormViolationView } from '@ethlete/types';
 import { FieldTree, ValidationError, TreeValidationResult, PathKind, FieldContext, SchemaPath, SchemaPathRules } from '@angular/forms/signals';
@@ -248,344 +248,6 @@ declare const createQueryErrorResponse: (error: unknown, retry?: {
     idempotent?: boolean;
 }) => QueryErrorResponse;
 
-type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
-    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state' | 'deps'>;
-    executeState: QueryExecuteState;
-};
-declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
-type QueryExecuteState = {
-    previousKey: WritableSignal<string | null>;
-};
-declare const setupQueryExecuteState: () => QueryExecuteState;
-type RunQueryExecuteOptions = {
-    allowCache?: boolean;
-    triggeredBy?: string;
-    /**
-     * Overrides the creator's (and the client's) `keepUnusedFor` for this execution. A cache entry shared
-     * by several queries keeps the shortest retention of the queries currently bound to it, so a query
-     * that asks for a shorter one only shortens the entry until it releases the entry again.
-     */
-    keepUnusedFor?: number;
-};
-type QueryExecuteOptions<TArgs extends QueryArgs> = {
-    executeOptions: CreateQueryExecuteOptions<TArgs>;
-    executeState: QueryExecuteState;
-    args: RequestArgs<TArgs> | null;
-    options?: RunQueryExecuteOptions;
-    isSecure?: boolean;
-    /** @see QueryRepositoryRequestOptions.isRefreshable */
-    isRefreshable?: boolean;
-};
-declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
-/**
- * Throws `ET800` once the same query runs with identical args more than five times in a row, each run
- * less than 100 ms after the previous one. Executions with different args (a search term typed fast,
- * a slider bound to `withArgs`) never count against each other.
- */
-declare const circularQueryDependencyChecker: () => {
-    check: (args: RequestArgs<QueryArgs> | null | undefined) => void;
-};
-
-/**
- * Why a batch of in-use entries was refreshed. The answer to "why did this refetch?", which the query
- * devtools spell out per query - the entries themselves only ever see a forced execution.
- */
-type QueryRefreshCause = {
-    /**
-     * - `refresh` - {@link QueryClient.refreshQueriesInUse}, which narrows nothing.
-     * - `invalidation` - {@link QueryClient.invalidateQueries}.
-     * - `mutation` - the multi-tab sync engine reacting to a mutation another tab made.
-     */
-    type: 'refresh' | 'invalidation' | 'mutation';
-    /** The URL the refresh was narrowed to (an invalidation's scope, a mutation's URL), or `null`. */
-    url: string | null;
-    /** Whether another tab asked for it rather than this one. */
-    otherTab: boolean;
-};
-/**
- * What tore a cache entry down: the last consumer went away (`unbind`), its `keepUnusedFor` window ran
- * out (`expired`), it was the least recently orphaned entry over the cap (`unused-cap`), a logout
- * dropped every secure entry (`logout`), or something evicted it by hand (`manual`).
- */
-type QueryRepositoryEntryDestroyedCause = 'unbind' | 'expired' | 'unused-cap' | 'logout' | 'manual';
-type QueryRepositoryEvent = {
-    type: 'request-error';
-    error: HttpErrorResponse;
-    key: QueryKey;
-    isSecure: boolean;
-    request: HttpRequest<QueryArgs>;
-} | {
-    type: 'request-success';
-    key: QueryKey;
-    isSecure: boolean;
-    request: HttpRequest<QueryArgs>;
-    /**
-     * Whether the request is held in the cache under a key every tab derives identically (a hash of
-     * route + args) rather than a per-request UUID. `false` for mutations and anything else
-     * uncacheable - which is exactly what tells the multi-tab sync engine whether a settled request
-     * is a shareable read or a mutation other tabs should react to.
-     */
-    isCached: boolean;
-    /** @see BaseQueryCreatorOptions.multiTabSync */
-    isMultiTabSyncEnabled: boolean;
-    /** @see QueryRepositoryRequestOptions.isRefreshable */
-    isRefreshable: boolean;
-    /**
-     * Whether this response may be written to the client's persisted store. Already accounts for
-     * secure requests needing an explicit opt-in.
-     *
-     * @see BaseQueryCreatorOptions.persistence
-     */
-    isPersistEnabled: boolean;
-} | {
-    /**
-     * A cache entry was created - the query behind it had nothing to bind to, so this is the moment a
-     * response from a previous session can still be of use. The persistence engine answers it by
-     * reading the key back from disk.
-     *
-     * Only ever emitted for entries that did not exist before; a consumer binding to an entry that is
-     * already there is not one of these.
-     */
-    type: 'entry-created';
-    key: QueryKey;
-    /** @see QueryRepositoryEvent.isCached */
-    isCached: boolean;
-    /** @see QueryRepositoryEvent.isPersistEnabled */
-    isPersistEnabled: boolean;
-} | {
-    /**
-     * A batch of in-use entries was re-executed at once. Emitted for every
-     * {@link QueryRepository.refreshInUse} call, including one that matched nothing - "the
-     * invalidation ran and hit no query" is an answer too.
-     */
-    type: 'queries-refreshed';
-    cause: QueryRefreshCause;
-    /** The requests that were re-executed, in cache order. */
-    requests: HttpRequest<QueryArgs>[];
-} | {
-    /**
-     * A cache entry was torn down: its request is destroyed and the key is gone from the cache.
-     * Emitted after the deletion, and for every teardown path there is - which is what makes "why
-     * did this entry disappear" answerable at all. {@link unbindAllSecure} emits one of these per
-     * entry as well as its own `unbind-all-secure`.
-     *
-     * The repository keeps no record of its own; a consumer that wants a history of destroyed
-     * entries (the devtools panel) is the one that keeps it.
-     */
-    type: 'entry-destroyed';
-    key: QueryKey;
-    isSecure: boolean;
-    method: QueryMethod;
-    url: string;
-    cause: QueryRepositoryEntryDestroyedCause;
-} | {
-    /**
-     * Every secure entry was torn down at once - a logout. Emitted after the cache is cleared so
-     * secure queries can drop the state they hold themselves; the repository only owns the
-     * requests, not the `response` signal of the query objects bound to them.
-     */
-    type: 'unbind-all-secure';
-};
-type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
-    /**
-     * The route of the request.
-     * @example '/users'
-     * @example (args) => `/users/${args.userId}`
-     */
-    route: RouteType<TArgs>;
-    /** The HTTP method of the request */
-    method: QueryMethod;
-    /** If the request is secure (needs authentication) */
-    isSecure?: boolean;
-    /** The data of the request */
-    args?: RequestArgs<TArgs> | null;
-    /** The query creator options of the request */
-    creatorOptions?: CreateQueryCreatorOptions;
-    /** Custom retry function for this specific request */
-    retryFn?: ShouldRetryRequestFn;
-    /** If set, this request's cache key will be prefixed with this key */
-    key?: string;
-    /** The previous tracking key of the request */
-    previousKey?: QueryKey | null;
-    /** The destroy ref to bind the request to. If the destroy ref is destroyed, the request will be destroyed as well. */
-    consumerDestroyRef: DestroyRef;
-    /** Configuration on how to run the query */
-    runQueryOptions?: RunQueryExecuteOptions;
-    /** @see QueryConfig.silenceUncacheableAllowCacheError */
-    silenceUncacheableAllowCacheError?: boolean;
-    /**
-     * Whether re-running the request on its own is safe, i.e. whether {@link QueryRepository.refreshInUse}
-     * may fire it again. Defaults to the method being a read (`GET`/`HEAD`/`OPTIONS`); the GraphQL
-     * execute path passes `true` for a query transported via `POST`. Also what the retry policy receives
-     * as `idempotent`; unset, that falls back to the method not being `POST` or `PATCH`.
-     */
-    isRefreshable?: boolean;
-};
-type QueryRepositoryItem<TArgs extends QueryArgs> = {
-    /** The key of the request (either a cache key for cacheable requests or a UUID for uncacheable requests) */
-    key: QueryKey;
-    /** The request object */
-    request: HttpRequest<TArgs>;
-    /**
-     * Whether this call started a network request. `false` when a fresh cache entry answered it, or when
-     * an identical request was already in flight - the consumer is bound to that request either way and
-     * still gets its response.
-     */
-    executed: boolean;
-};
-/**
- * A read-only snapshot of a single cache entry, exposed via {@link QueryRepositorySubtle.cacheEntries}
- * for devtools inspection. The raw cache `Map` is never exposed.
- */
-type QueryRepositoryCacheEntry = {
-    /** The cache key of the entry. */
-    key: QueryKey;
-    /** Whether the entry belongs to a secure (authenticated) request. */
-    isSecure: boolean;
-    /** How many consumers currently hold a binding to the entry. */
-    consumerCount: number;
-    /**
-     * Whether the entry has no consumers left and is only being kept around for its
-     * `keepUnusedFor` window. Such an entry is not a leak - it is waiting to be reused by a
-     * consumer that comes back.
-     */
-    isUnused: boolean;
-    /** The underlying HTTP request. */
-    request: HttpRequest<QueryArgs>;
-};
-/**
- * Advanced repository internals used by the query devtools. **Not part of the general public
- * contract** - do not build application logic on top of these.
- */
-type QueryRepositorySubtle = {
-    /** Returns a read-only snapshot of every entry currently held in the cache. */
-    cacheEntries: () => QueryRepositoryCacheEntry[];
-    /** A version counter bumped whenever the cache changes (bind / unbind / unbindAllSecure). */
-    cacheVersion: Signal<number>;
-    /**
-     * Destroys and removes a single cache entry by key, regardless of its consumers. Intended for
-     * devtools cache management - consumers still holding the query will get a fresh request on their
-     * next execution.
-     */
-    evict: (key: QueryKey) => void;
-};
-/**
- * Narrows which in-use entries a {@link QueryRepository.refreshInUse} call refreshes. Returning
- * `false` leaves the entry alone.
- */
-type QueryRepositoryRefreshFilterFn = (request: HttpRequest<QueryArgs>) => boolean;
-/** @see QueryRepository.applyExternalResponse */
-type ApplyExternalResponseOptions = {
-    /** The cache key the response belongs to. */
-    key: QueryKey;
-    /** The response body, as received from the other tab. */
-    body: unknown;
-    /** Timestamp (ms) at which the response goes stale, or `null` when it has no freshness window. */
-    expiresAt: number | null;
-};
-/** @see QueryRepository.applyPersistedResponse */
-type ApplyPersistedResponseOptions = {
-    /** The cache key the response belongs to. */
-    key: QueryKey;
-    /** The response body, as it was read back from the store. */
-    body: unknown;
-    /**
-     * Timestamp (ms) at which the response goes stale, as it was when the response was persisted - so
-     * usually in the past, which is exactly right: the entry revalidates and the data is shown meanwhile.
-     */
-    expiresAt: number | null;
-};
-/**
- * The query repository is responsible for managing all requests and their consumers.
- * It will cache requests if they can be cached and reuse them if they are already cached.
- * It will also destroy requests if there are no more consumers left.
- */
-type QueryRepository = {
-    /** Creates a new request. If the request is already cached, it will be reused. */
-    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => QueryRepositoryItem<TArgs>;
-    /** Removes a consumer from a request by its key. Destroys the request if there are no more consumers left. */
-    unbind: (key: QueryKey | null, consumerDestroyRef: DestroyRef) => boolean;
-    /** Removes all secure requests and their consumers */
-    unbindAllSecure: () => void;
-    /**
-     * Re-executes every cacheable entry that still has consumers, bypassing the cache and restarting
-     * in-flight requests. Entries kept only for their `keepUnusedFor` window are skipped - nobody is
-     * looking at them, and they revalidate on their own when a consumer binds again.
-     *
-     * Pass a filter to narrow it down to a subset of those entries, and a cause to describe what asked
-     * for it - which is what the devtools report as the reason a query refetched.
-     *
-     * @see QueryClient.refreshQueriesInUse
-     */
-    refreshInUse: (filter?: QueryRepositoryRefreshFilterFn, cause?: QueryRefreshCause) => void;
-    /**
-     * Writes a response that another tab received onto the matching cache entry, so the same query
-     * shows the same data everywhere without a second network request.
-     *
-     * Returns whether it was applied. It is skipped when
-     * - no entry exists for the key: cold entries are never seeded on speculation, that would be
-     *   unbounded memory for data nobody in this tab is looking at,
-     * - the entry's creator opted out of {@link BaseQueryCreatorOptions.multiTabSync},
-     * - or the entry has a request in flight, which is at least as fresh and overwrites this anyway.
-     *
-     * Entries sitting out their `keepUnusedFor` window without consumers *are* updated - it costs
-     * nothing and means a returning consumer renders data that is current rather than merely recent.
-     */
-    applyExternalResponse: (options: ApplyExternalResponseOptions) => boolean;
-    /**
-     * Writes a response from a previous session - read back from the client's persisted store - onto a
-     * cache entry that has nothing of its own yet.
-     *
-     * Returns whether it was applied. It is skipped when
-     * - no entry exists for the key: the entry was destroyed again while the store was being read,
-     * - the entry's creator opted out of {@link BaseQueryCreatorOptions.persistence},
-     * - or the entry already holds a response - from its own request, or from another tab. Persisted data
-     *   only ever fills a gap; it never replaces something newer.
-     *
-     * Note that the entry's request is *not* stopped: hydration happens while it is already in flight, so
-     * persisted data is always shown alongside a revalidation rather than instead of one. An entry whose
-     * request already failed keeps its error, which is what makes the offline case honest - the data is
-     * from disk, and the attempt to refresh it did fail.
-     */
-    applyPersistedResponse: (options: ApplyPersistedResponseOptions) => boolean;
-    /** Observable stream of repository events (errors, successes, etc.) */
-    events$: Observable<QueryRepositoryEvent>;
-    /** Advanced repository internals used by the query devtools. */
-    subtle: QueryRepositorySubtle;
-};
-/** The key of a query (either a cache key for cacheable requests or a UUID for uncacheable requests) */
-type QueryKey = string;
-/** Runs .unbind() if the DestroyRef.onDestroy() gets called */
-type DestroyCleanupCallback = () => void;
-type QueryRepositoryDependencies = {
-    /** The HTTP client to use for the requests */
-    httpClient: HttpClient;
-    /** The error handler to use for the requests */
-    ngErrorHandler: ErrorHandler;
-    /** The injector to use for reactive operations like signal->observable conversions */
-    injector: Injector;
-};
-type CreateQueryRepositoryConfig = CreateQueryClientConfigOptions & {
-    /** The dependencies of the query repository */
-    dependencies: QueryRepositoryDependencies;
-    /**
-     * Whether unused entries may be retained at all. `false` forces `keepUnusedFor` to `0` everywhere,
-     * regardless of client or creator configuration - used to disable retention on the server, where a
-     * per-request injector must not hold response bodies (and a pending timer) for minutes.
-     * @default true
-     */
-    retentionEnabled?: boolean;
-};
-/** @see CreateQueryClientConfigOptions.keepUnusedFor */
-declare const DEFAULT_KEEP_UNUSED_FOR = 300000;
-/**
- * Hard cap on entries kept without consumers, per client. Retention is opportunistic, so a runaway
- * count (a search-as-you-type query produces a new cache key per keystroke, and each one goes through
- * `unbind`) must never grow unbounded - the least recently orphaned entries are dropped first.
- */
-declare const MAX_UNUSED_ENTRIES = 50;
-declare const createQueryRepository: (config: CreateQueryRepositoryConfig) => QueryRepository;
-
 /** Which query forms a query reads while it builds its args. */
 type QueryDevtoolsFormLinksHandle = {
     /**
@@ -835,229 +497,586 @@ type QueryDevtoolsPayload = {
     body: unknown;
 };
 /**
- * How one run of a query ended. `aborted` is a run whose query started another request before the
- * response arrived - the previous request's events are unbound at that point, so the response it was
- * waiting for can no longer reach it.
+ * How one run of a query ended. `aborted` is a run whose query started another request before the
+ * response arrived - the previous request's events are unbound at that point, so the response it was
+ * waiting for can no longer reach it.
+ */
+type QueryDevtoolsRunStatus = 'pending' | 'success' | 'error' | 'aborted';
+/**
+ * How a run failed, kept on the run itself. The query's own `error` signal is the live one, but it is
+ * blanked whenever the query resets - a logout resets every secure query - so it cannot be read back
+ * after the fact. This is the copy that survives.
+ */
+type QueryDevtoolsRunError = {
+    /** The HTTP status code, or 0 for a failure that never reached a response. */
+    code: number;
+    /** Every message the error carried, flattened. @see queryErrorMessages */
+    messages: string[];
+    /**
+     * The error response body. Only the newest few runs keep theirs, under the same budget as
+     * {@link QueryDevtoolsRun.response}.
+     */
+    body: unknown;
+    /** Whether {@link body} still holds this run's error body. */
+    hasBody: boolean;
+};
+/**
+ * A single run of a query, kept alongside the running totals so overlapping runs stay tellable apart -
+ * which is what turns "ran 40 times" into "ran 40 times in two seconds".
+ */
+type QueryDevtoolsRun = {
+    /**
+     * Position in the query's lifetime, 1-based. Keeps climbing past the runs the buffer has dropped, so
+     * it is a stable identity as well as a run number.
+     */
+    index: number;
+    startedAt: number;
+    /** When the run ended, or `null` while it is still in flight. */
+    endedAt: number | null;
+    status: QueryDevtoolsRunStatus;
+    /**
+     * Whether this run is a request of the query's own. A response that arrives without one was produced
+     * by something else - a poll, another consumer of the same cache entry, another tab - and is recorded
+     * as an instant, since only its arrival time is knowable.
+     */
+    didRequest: boolean;
+    /**
+     * The URL this run went to. Kept per run rather than read off the query: a query whose args changed
+     * between runs would otherwise label every older run with the URL it happens to hold now.
+     */
+    url: string | null;
+    /**
+     * How many HTTP attempts this run took - 1 unless the retry policy fired, and 0 for a run that made no
+     * request of its own. Which is what tells a slow response apart from one that was retried into place.
+     */
+    attempts: number;
+    /** The size of the request body this run sent. */
+    sentBytes: number;
+    /** The size of the response body it received, or 0 until one has. */
+    receivedBytes: number;
+    /**
+     * The response body, so one run can be diffed against another. Only the newest few runs keep theirs -
+     * a polling query would otherwise retain every response it ever received.
+     */
+    response: unknown;
+    /** Whether {@link response} still holds this run's body; a dropped and an empty body both read `null`. */
+    hasResponse: boolean;
+    /** How the run failed, or `null` for one that did not. */
+    error: QueryDevtoolsRunError | null;
+};
+/** The read side of a stats recorder, as a {@link QueryDevtoolsEntry} exposes it to the panel. */
+type QueryDevtoolsStatsHandle = {
+    /** The live stats. */
+    current: Signal<QueryDevtoolsStats>;
+    /** The query's most recent runs, oldest first. Bounded - older runs are dropped as new ones arrive. */
+    runs: Signal<readonly QueryDevtoolsRun[]>;
+    /** Clears every counter, so a measurement can be scoped to a single interaction. */
+    reset: () => void;
+};
+/** The write side, used by the instrumentation inside the query itself. */
+type QueryDevtoolsStatsRecorder = QueryDevtoolsStatsHandle & {
+    recordExecution: (options: {
+        /** Whether the execution started a request, as reported by the repository. */
+        didRequest: boolean;
+        /** The request body it sent, for the outgoing byte count. */
+        body?: unknown;
+        /** The URL it went to. @see QueryDevtoolsRun.url */
+        url?: string;
+    }) => void;
+    recordResponse: (payload: QueryDevtoolsPayload) => void;
+    recordError: (options?: {
+        /** Whether the error is a devtools fault rather than a real failure. */
+        faulted?: boolean;
+        /** The failure itself, for {@link QueryDevtoolsRun.error}. */
+        error?: QueryErrorResponse;
+    }) => void;
+    /**
+     * Raises the attempt count of the run in flight. Idempotent per attempt, so a caller driven off a
+     * signal may report the same attempt more than once without inflating {@link QueryDevtoolsStats.retries}.
+     */
+    recordRetry: (options: {
+        attempt: number;
+    }) => void;
+};
+/**
+ * How many bodies each query retains: what the panel's Settings tab asks for, or
+ * {@link QueryDevtoolsOptions.responseHistory}, or `5`. Only a run that still holds one can be an end of
+ * a response diff, so the panel reads this to say why an older run can no longer be picked.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsResponseHistory: () => number;
+/**
+ * The size of a payload in bytes, and whether that size is the one that went over the wire. Only a
+ * `content-length` header is exact; everything else is measured by serializing the body.
+ *
+ * Part of the devtools contract - the panel measures the cache and the event log with it. **Not part of
+ * the general public contract.**
+ */
+declare const measureQueryDevtoolsPayload: (payload: QueryDevtoolsPayload) => {
+    bytes: number;
+    isExact: boolean;
+};
+/**
+ * Adds up the stats of several entries, for a stack's or a client's total. `lastDurationMs` is taken from
+ * whichever entry responded most recently rather than summed.
+ */
+declare const sumQueryDevtoolsStats: (handles: readonly (QueryDevtoolsStatsHandle | undefined)[]) => QueryDevtoolsStats;
+
+type SetupQueryStateOptions<TArgs extends QueryArgs> = {
+    transformResponse?: (rawResponse: RawResponseType<TArgs>) => ResponseType<TArgs>;
+    destroyRef?: DestroyRef;
+    keepPreviousResponse?: boolean;
+    /**
+     * The devtools stats recorder to feed from this state's executions, or nothing when the devtools are
+     * not installed.
+     */
+    devtoolsStats?: QueryDevtoolsStatsRecorder | null;
+    /**
+     * The recorder that notes which query forms the args source reads, or nothing when the devtools are
+     * not installed.
+     */
+    devtoolsFormLinks?: QueryDevtoolsFormLinksRecorder | null;
+    /**
+     * The recorder of response overrides armed on this query, or nothing when the devtools are not
+     * installed. Replayed against every response that settles into {@link QueryState.rawResponse}.
+     */
+    devtoolsOverrides?: QueryDevtoolsOverridesRecorder | null;
+};
+type QueryStateSubtle<TArgs extends QueryArgs> = {
+    request: WritableSignal<HttpRequest<TArgs> | null>;
+    rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
+    /**
+     * Forwards the given request's discrete event stream onto the query-level `events$`.
+     * Called by `queryExecute` whenever a request is (re-)executed.
+     */
+    bindRequestEvents: (request: HttpRequest<TArgs>) => void;
+    /** Stops forwarding the current request's events; `reset()` detaches the query from its request with it. */
+    unbindRequestEvents: () => void;
+    /**
+     * Run options every execution of this query starts from; the options passed to one `execute()` win
+     * per field. Set by a feature during creation so it also covers executions the feature does not
+     * trigger itself (`withLongPolling` turns retention off for the `withArgs` round too).
+     */
+    defaultRunOptions: WritableSignal<RunQueryExecuteOptions | null>;
+    /**
+     * Consulted before `withArgs` or creation auto-executes the query; returning `false` skips that
+     * execution. Set by a feature during creation (`withLongPolling` holds its first round back while disabled).
+     */
+    autoExecuteGuard: WritableSignal<(() => boolean) | null>;
+    /**
+     * Installs the reactive source that backs `state.args`. The `withArgs` feature uses this so that
+     * `state.args` always reflects the latest args (pulled from the reactive source on read) instead
+     * of being push-updated by an effect that may not have run yet. Without a `withArgs` feature the
+     * default source returns `null`.
+     */
+    setArgsSource: (source: () => RequestArgs<TArgs> | null) => void;
+    /** Whether {@link setArgsSource} installed a source. Without one, an execution's args are written to `state.args`. */
+    hasArgsSource: Signal<boolean>;
+    /** @see SetupQueryStateOptions.devtoolsStats */
+    devtoolsStats: QueryDevtoolsStatsRecorder | null;
+    /** @see SetupQueryStateOptions.devtoolsFormLinks */
+    devtoolsFormLinks: QueryDevtoolsFormLinksRecorder | null;
+};
+type QueryState<TArgs extends QueryArgs> = {
+    rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
+    response: WritableSignal<ResponseType<TArgs> | null>;
+    args: WritableSignal<RequestArgs<TArgs> | null>;
+    latestHttpEvent: WritableSignal<RequestHttpEvent<TArgs> | null>;
+    loading: WritableSignal<HttpRequestLoadingState | null>;
+    error: WritableSignal<QueryErrorResponse | null>;
+    lastTimeExecutedAt: WritableSignal<number | null>;
+    lastTriggeredBy: WritableSignal<string | null>;
+    executionState: Signal<QueryExecutionState<TArgs> | null>;
+    /**
+     * A discrete, query-level stream of every request event, fed synchronously from the current
+     * request's `events$` at the moment each event occurs. Side-effect features
+     * (success/error/logging) subscribe to this instead of edge-detecting on the shared, resettable
+     * `response`/`error`/`latestHttpEvent` signals - so they cannot miss a transition when the next
+     * execution swaps the underlying request.
+     */
+    events$: Observable<RequestHttpEvent<TArgs>>;
+    subtle: QueryStateSubtle<TArgs>;
+};
+type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
+    type: 'success';
+    response: ResponseType<TArgs>;
+};
+type QueryExecutionStateFailureWithNoResponse = {
+    type: 'failure';
+    error: QueryErrorResponse;
+    hasCachedResponse?: false;
+};
+type QueryExecutionStateFailureWithCachedResponse<TArgs extends QueryArgs> = {
+    type: 'failure';
+    error: QueryErrorResponse;
+    hasCachedResponse: true;
+    cachedResponse: ResponseType<TArgs>;
+};
+type QueryExecutionStateFailure<TArgs extends QueryArgs> = QueryExecutionStateFailureWithNoResponse | QueryExecutionStateFailureWithCachedResponse<TArgs>;
+type QueryExecutionStateLoadingWithNoResponse = {
+    type: 'loading';
+    hasCachedResponse: false;
+    loading: HttpRequestLoadingState;
+};
+type QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = {
+    type: 'loading';
+    hasCachedResponse: true;
+    loading: HttpRequestLoadingState;
+    cachedResponse: ResponseType<TArgs>;
+};
+type QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithNoResponse | QueryExecutionStateLoadingWithCachedResponse<TArgs>;
+type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure<TArgs> | QueryExecutionStateLoading<TArgs>;
+declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions<TArgs>) => QueryState<TArgs>;
+
+type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
+    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state' | 'deps'>;
+    executeState: QueryExecuteState;
+};
+declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
+type QueryExecuteState = {
+    previousKey: WritableSignal<string | null>;
+};
+declare const setupQueryExecuteState: () => QueryExecuteState;
+type RunQueryExecuteOptions = {
+    allowCache?: boolean;
+    triggeredBy?: string;
+    /**
+     * Overrides the creator's (and the client's) `keepUnusedFor` for this execution. A cache entry shared
+     * by several queries keeps the shortest retention of the queries currently bound to it, so a query
+     * that asks for a shorter one only shortens the entry until it releases the entry again.
+     */
+    keepUnusedFor?: number;
+};
+type QueryExecuteOptions<TArgs extends QueryArgs> = {
+    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeState: QueryExecuteState;
+    args: RequestArgs<TArgs> | null;
+    options?: RunQueryExecuteOptions;
+    isSecure?: boolean;
+    /** @see QueryRepositoryRequestOptions.isRefreshable */
+    isRefreshable?: boolean;
+};
+declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+/**
+ * Writes the args an execution runs with to `state.args`, so a later bare `execute()` re-sends them.
+ * A `withArgs` source owns `state.args`, and a `withLongPolling` round must not look like a new
+ * args value, so neither is written.
  */
-type QueryDevtoolsRunStatus = 'pending' | 'success' | 'error' | 'aborted';
+declare const recordExecutionArgs: <TArgs extends QueryArgs>(state: QueryState<TArgs>, args: RequestArgs<TArgs> | null, options?: RunQueryExecuteOptions) => void;
 /**
- * How a run failed, kept on the run itself. The query's own `error` signal is the live one, but it is
- * blanked whenever the query resets - a logout resets every secure query - so it cannot be read back
- * after the fact. This is the copy that survives.
+ * Throws `ET800` once the same query runs with identical args more than five times in a row, each run
+ * less than 100 ms after the previous one. Executions with different args (a search term typed fast,
+ * a slider bound to `withArgs`) never count against each other.
  */
-type QueryDevtoolsRunError = {
-    /** The HTTP status code, or 0 for a failure that never reached a response. */
-    code: number;
-    /** Every message the error carried, flattened. @see queryErrorMessages */
-    messages: string[];
+declare const circularQueryDependencyChecker: () => {
+    check: (args: RequestArgs<QueryArgs> | null | undefined) => void;
+};
+
+/**
+ * Why a batch of in-use entries was refreshed. The answer to "why did this refetch?", which the query
+ * devtools spell out per query - the entries themselves only ever see a forced execution.
+ */
+type QueryRefreshCause = {
     /**
-     * The error response body. Only the newest few runs keep theirs, under the same budget as
-     * {@link QueryDevtoolsRun.response}.
+     * - `refresh` - {@link QueryClient.refreshQueriesInUse}, which narrows nothing.
+     * - `invalidation` - {@link QueryClient.invalidateQueries}.
+     * - `mutation` - the multi-tab sync engine reacting to a mutation another tab made.
      */
-    body: unknown;
-    /** Whether {@link body} still holds this run's error body. */
-    hasBody: boolean;
+    type: 'refresh' | 'invalidation' | 'mutation';
+    /** The URL the refresh was narrowed to (an invalidation's scope, a mutation's URL), or `null`. */
+    url: string | null;
+    /** Whether another tab asked for it rather than this one. */
+    otherTab: boolean;
 };
 /**
- * A single run of a query, kept alongside the running totals so overlapping runs stay tellable apart -
- * which is what turns "ran 40 times" into "ran 40 times in two seconds".
+ * What tore a cache entry down: the last consumer went away (`unbind`), its `keepUnusedFor` window ran
+ * out (`expired`), it was the least recently orphaned entry over the cap (`unused-cap`), a logout
+ * dropped every secure entry (`logout`), or something evicted it by hand (`manual`).
  */
-type QueryDevtoolsRun = {
+type QueryRepositoryEntryDestroyedCause = 'unbind' | 'expired' | 'unused-cap' | 'logout' | 'manual';
+type QueryRepositoryEvent = {
+    type: 'request-error';
+    error: HttpErrorResponse;
+    key: QueryKey;
+    isSecure: boolean;
+    request: HttpRequest<QueryArgs>;
+} | {
+    type: 'request-success';
+    key: QueryKey;
+    isSecure: boolean;
+    request: HttpRequest<QueryArgs>;
     /**
-     * Position in the query's lifetime, 1-based. Keeps climbing past the runs the buffer has dropped, so
-     * it is a stable identity as well as a run number.
+     * Whether the request is held in the cache under a key every tab derives identically (a hash of
+     * route + args) rather than a per-request UUID. `false` for mutations and anything else
+     * uncacheable - which is exactly what tells the multi-tab sync engine whether a settled request
+     * is a shareable read or a mutation other tabs should react to.
      */
-    index: number;
-    startedAt: number;
-    /** When the run ended, or `null` while it is still in flight. */
-    endedAt: number | null;
-    status: QueryDevtoolsRunStatus;
+    isCached: boolean;
+    /** @see BaseQueryCreatorOptions.multiTabSync */
+    isMultiTabSyncEnabled: boolean;
+    /** @see QueryRepositoryRequestOptions.isRefreshable */
+    isRefreshable: boolean;
     /**
-     * Whether this run is a request of the query's own. A response that arrives without one was produced
-     * by something else - a poll, another consumer of the same cache entry, another tab - and is recorded
-     * as an instant, since only its arrival time is knowable.
+     * Whether this response may be written to the client's persisted store. Already accounts for
+     * secure requests needing an explicit opt-in.
+     *
+     * @see BaseQueryCreatorOptions.persistence
      */
-    didRequest: boolean;
+    isPersistEnabled: boolean;
+} | {
     /**
-     * The URL this run went to. Kept per run rather than read off the query: a query whose args changed
-     * between runs would otherwise label every older run with the URL it happens to hold now.
+     * A cache entry was created - the query behind it had nothing to bind to, so this is the moment a
+     * response from a previous session can still be of use. The persistence engine answers it by
+     * reading the key back from disk.
+     *
+     * Only ever emitted for entries that did not exist before; a consumer binding to an entry that is
+     * already there is not one of these.
      */
-    url: string | null;
+    type: 'entry-created';
+    key: QueryKey;
+    /** @see QueryRepositoryEvent.isCached */
+    isCached: boolean;
+    /** @see QueryRepositoryEvent.isPersistEnabled */
+    isPersistEnabled: boolean;
+} | {
     /**
-     * How many HTTP attempts this run took - 1 unless the retry policy fired, and 0 for a run that made no
-     * request of its own. Which is what tells a slow response apart from one that was retried into place.
+     * A batch of in-use entries was re-executed at once. Emitted for every
+     * {@link QueryRepository.refreshInUse} call, including one that matched nothing - "the
+     * invalidation ran and hit no query" is an answer too.
      */
-    attempts: number;
-    /** The size of the request body this run sent. */
-    sentBytes: number;
-    /** The size of the response body it received, or 0 until one has. */
-    receivedBytes: number;
+    type: 'queries-refreshed';
+    cause: QueryRefreshCause;
+    /** The requests that were re-executed, in cache order. */
+    requests: HttpRequest<QueryArgs>[];
+} | {
     /**
-     * The response body, so one run can be diffed against another. Only the newest few runs keep theirs -
-     * a polling query would otherwise retain every response it ever received.
+     * A cache entry was torn down: its request is destroyed and the key is gone from the cache.
+     * Emitted after the deletion, and for every teardown path there is - which is what makes "why
+     * did this entry disappear" answerable at all. {@link unbindAllSecure} emits one of these per
+     * entry as well as its own `unbind-all-secure`.
+     *
+     * The repository keeps no record of its own; a consumer that wants a history of destroyed
+     * entries (the devtools panel) is the one that keeps it.
      */
-    response: unknown;
-    /** Whether {@link response} still holds this run's body; a dropped and an empty body both read `null`. */
-    hasResponse: boolean;
-    /** How the run failed, or `null` for one that did not. */
-    error: QueryDevtoolsRunError | null;
+    type: 'entry-destroyed';
+    key: QueryKey;
+    isSecure: boolean;
+    method: QueryMethod;
+    url: string;
+    cause: QueryRepositoryEntryDestroyedCause;
+} | {
+    /**
+     * Every secure entry was torn down at once - a logout. Emitted after the cache is cleared so
+     * secure queries can drop the state they hold themselves; the repository only owns the
+     * requests, not the `response` signal of the query objects bound to them.
+     */
+    type: 'unbind-all-secure';
 };
-/** The read side of a stats recorder, as a {@link QueryDevtoolsEntry} exposes it to the panel. */
-type QueryDevtoolsStatsHandle = {
-    /** The live stats. */
-    current: Signal<QueryDevtoolsStats>;
-    /** The query's most recent runs, oldest first. Bounded - older runs are dropped as new ones arrive. */
-    runs: Signal<readonly QueryDevtoolsRun[]>;
-    /** Clears every counter, so a measurement can be scoped to a single interaction. */
-    reset: () => void;
+type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
+    /**
+     * The route of the request.
+     * @example '/users'
+     * @example (args) => `/users/${args.userId}`
+     */
+    route: RouteType<TArgs>;
+    /** The HTTP method of the request */
+    method: QueryMethod;
+    /** If the request is secure (needs authentication) */
+    isSecure?: boolean;
+    /** The data of the request */
+    args?: RequestArgs<TArgs> | null;
+    /** The query creator options of the request */
+    creatorOptions?: CreateQueryCreatorOptions;
+    /** Custom retry function for this specific request */
+    retryFn?: ShouldRetryRequestFn;
+    /** If set, this request's cache key will be prefixed with this key */
+    key?: string;
+    /** The previous tracking key of the request */
+    previousKey?: QueryKey | null;
+    /** The destroy ref to bind the request to. If the destroy ref is destroyed, the request will be destroyed as well. */
+    consumerDestroyRef: DestroyRef;
+    /** Configuration on how to run the query */
+    runQueryOptions?: RunQueryExecuteOptions;
+    /** @see QueryConfig.silenceUncacheableAllowCacheError */
+    silenceUncacheableAllowCacheError?: boolean;
+    /**
+     * Whether re-running the request on its own is safe, i.e. whether {@link QueryRepository.refreshInUse}
+     * may fire it again. Defaults to the method being a read (`GET`/`HEAD`/`OPTIONS`); the GraphQL
+     * execute path passes `true` for a query transported via `POST`. Also what the retry policy receives
+     * as `idempotent`; unset, that falls back to the method not being `POST` or `PATCH`.
+     */
+    isRefreshable?: boolean;
 };
-/** The write side, used by the instrumentation inside the query itself. */
-type QueryDevtoolsStatsRecorder = QueryDevtoolsStatsHandle & {
-    recordExecution: (options: {
-        /** Whether the execution started a request, as reported by the repository. */
-        didRequest: boolean;
-        /** The request body it sent, for the outgoing byte count. */
-        body?: unknown;
-        /** The URL it went to. @see QueryDevtoolsRun.url */
-        url?: string;
-    }) => void;
-    recordResponse: (payload: QueryDevtoolsPayload) => void;
-    recordError: (options?: {
-        /** Whether the error is a devtools fault rather than a real failure. */
-        faulted?: boolean;
-        /** The failure itself, for {@link QueryDevtoolsRun.error}. */
-        error?: QueryErrorResponse;
-    }) => void;
+type QueryRepositoryItem<TArgs extends QueryArgs> = {
+    /** The key of the request (either a cache key for cacheable requests or a UUID for uncacheable requests) */
+    key: QueryKey;
+    /** The request object */
+    request: HttpRequest<TArgs>;
     /**
-     * Raises the attempt count of the run in flight. Idempotent per attempt, so a caller driven off a
-     * signal may report the same attempt more than once without inflating {@link QueryDevtoolsStats.retries}.
+     * Whether this call started a network request. `false` when a fresh cache entry answered it, or when
+     * an identical request was already in flight - the consumer is bound to that request either way and
+     * still gets its response.
      */
-    recordRetry: (options: {
-        attempt: number;
-    }) => void;
+    executed: boolean;
 };
 /**
- * How many bodies each query retains: what the panel's Settings tab asks for, or
- * {@link QueryDevtoolsOptions.responseHistory}, or `5`. Only a run that still holds one can be an end of
- * a response diff, so the panel reads this to say why an older run can no longer be picked.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * A read-only snapshot of a single cache entry, exposed via {@link QueryRepositorySubtle.cacheEntries}
+ * for devtools inspection. The raw cache `Map` is never exposed.
  */
-declare const queryDevtoolsResponseHistory: () => number;
+type QueryRepositoryCacheEntry = {
+    /** The cache key of the entry. */
+    key: QueryKey;
+    /** Whether the entry belongs to a secure (authenticated) request. */
+    isSecure: boolean;
+    /** How many consumers currently hold a binding to the entry. */
+    consumerCount: number;
+    /**
+     * Whether the entry has no consumers left and is only being kept around for its
+     * `keepUnusedFor` window. Such an entry is not a leak - it is waiting to be reused by a
+     * consumer that comes back.
+     */
+    isUnused: boolean;
+    /** The underlying HTTP request. */
+    request: HttpRequest<QueryArgs>;
+};
 /**
- * The size of a payload in bytes, and whether that size is the one that went over the wire. Only a
- * `content-length` header is exact; everything else is measured by serializing the body.
- *
- * Part of the devtools contract - the panel measures the cache and the event log with it. **Not part of
- * the general public contract.**
+ * Advanced repository internals used by the query devtools. **Not part of the general public
+ * contract** - do not build application logic on top of these.
  */
-declare const measureQueryDevtoolsPayload: (payload: QueryDevtoolsPayload) => {
-    bytes: number;
-    isExact: boolean;
+type QueryRepositorySubtle = {
+    /** Returns a read-only snapshot of every entry currently held in the cache. */
+    cacheEntries: () => QueryRepositoryCacheEntry[];
+    /** A version counter bumped whenever the cache changes (bind / unbind / unbindAllSecure). */
+    cacheVersion: Signal<number>;
+    /**
+     * Destroys and removes a single cache entry by key, regardless of its consumers. Intended for
+     * devtools cache management - consumers still holding the query will get a fresh request on their
+     * next execution.
+     */
+    evict: (key: QueryKey) => void;
 };
 /**
- * Adds up the stats of several entries, for a stack's or a client's total. `lastDurationMs` is taken from
- * whichever entry responded most recently rather than summed.
+ * Narrows which in-use entries a {@link QueryRepository.refreshInUse} call refreshes. Returning
+ * `false` leaves the entry alone.
  */
-declare const sumQueryDevtoolsStats: (handles: readonly (QueryDevtoolsStatsHandle | undefined)[]) => QueryDevtoolsStats;
-
-type SetupQueryStateOptions<TArgs extends QueryArgs> = {
-    transformResponse?: (rawResponse: RawResponseType<TArgs>) => ResponseType<TArgs>;
-    destroyRef?: DestroyRef;
-    /**
-     * The devtools stats recorder to feed from this state's executions, or nothing when the devtools are
-     * not installed.
-     */
-    devtoolsStats?: QueryDevtoolsStatsRecorder | null;
-    /**
-     * The recorder that notes which query forms the args source reads, or nothing when the devtools are
-     * not installed.
-     */
-    devtoolsFormLinks?: QueryDevtoolsFormLinksRecorder | null;
+type QueryRepositoryRefreshFilterFn = (request: HttpRequest<QueryArgs>) => boolean;
+/** @see QueryRepository.applyExternalResponse */
+type ApplyExternalResponseOptions = {
+    /** The cache key the response belongs to. */
+    key: QueryKey;
+    /** The response body, as received from the other tab. */
+    body: unknown;
+    /** Timestamp (ms) at which the response goes stale, or `null` when it has no freshness window. */
+    expiresAt: number | null;
+};
+/** @see QueryRepository.applyPersistedResponse */
+type ApplyPersistedResponseOptions = {
+    /** The cache key the response belongs to. */
+    key: QueryKey;
+    /** The response body, as it was read back from the store. */
+    body: unknown;
     /**
-     * The recorder of response overrides armed on this query, or nothing when the devtools are not
-     * installed. Replayed against every response that settles into {@link QueryState.rawResponse}.
+     * Timestamp (ms) at which the response goes stale, as it was when the response was persisted - so
+     * usually in the past, which is exactly right: the entry revalidates and the data is shown meanwhile.
      */
-    devtoolsOverrides?: QueryDevtoolsOverridesRecorder | null;
+    expiresAt: number | null;
 };
-type QueryStateSubtle<TArgs extends QueryArgs> = {
-    request: WritableSignal<HttpRequest<TArgs> | null>;
-    rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
+/**
+ * The query repository is responsible for managing all requests and their consumers.
+ * It will cache requests if they can be cached and reuse them if they are already cached.
+ * It will also destroy requests once no consumers are left, unless `keepUnusedFor` retains their response.
+ */
+type QueryRepository = {
+    /** Creates a new request. If the request is already cached, it will be reused. */
+    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => QueryRepositoryItem<TArgs>;
     /**
-     * Forwards the given request's discrete event stream onto the query-level `events$`.
-     * Called by `queryExecute` whenever a request is (re-)executed.
+     * Removes a consumer from a request by its key. With no consumers left, the request is destroyed, or
+     * kept for `keepUnusedFor` if that is above 0 and it has a response.
      */
-    bindRequestEvents: (request: HttpRequest<TArgs>) => void;
-    /** Stops forwarding the current request's events; `reset()` detaches the query from its request with it. */
-    unbindRequestEvents: () => void;
+    unbind: (key: QueryKey | null, consumerDestroyRef: DestroyRef) => boolean;
+    /** Removes all secure requests and their consumers */
+    unbindAllSecure: () => void;
     /**
-     * Run options every execution of this query starts from; the options passed to one `execute()` win
-     * per field. Set by a feature during creation so it also covers executions the feature does not
-     * trigger itself (`withLongPolling` turns retention off for the `withArgs` round too).
+     * Re-executes every cacheable entry that still has consumers, bypassing the cache and restarting
+     * in-flight requests. Entries kept only for their `keepUnusedFor` window are skipped - nobody is
+     * looking at them, and they revalidate on their own when a consumer binds again.
+     *
+     * Pass a filter to narrow it down to a subset of those entries, and a cause to describe what asked
+     * for it - which is what the devtools report as the reason a query refetched.
+     *
+     * @see QueryClient.refreshQueriesInUse
      */
-    defaultRunOptions: WritableSignal<RunQueryExecuteOptions | null>;
+    refreshInUse: (filter?: QueryRepositoryRefreshFilterFn, cause?: QueryRefreshCause) => void;
     /**
-     * Installs the reactive source that backs `state.args`. The `withArgs` feature uses this so that
-     * `state.args` always reflects the latest args (pulled from the reactive source on read) instead
-     * of being push-updated by an effect that may not have run yet. Without a `withArgs` feature the
-     * default source returns `null`.
+     * Writes a response that another tab received onto the matching cache entry, so the same query
+     * shows the same data everywhere without a second network request.
+     *
+     * Returns whether it was applied. It is skipped when
+     * - no entry exists for the key: cold entries are never seeded on speculation, that would be
+     *   unbounded memory for data nobody in this tab is looking at,
+     * - the entry's creator opted out of {@link BaseQueryCreatorOptions.multiTabSync},
+     * - or the entry has a request in flight, which is at least as fresh and overwrites this anyway.
+     *
+     * Entries sitting out their `keepUnusedFor` window without consumers *are* updated - it costs
+     * nothing and means a returning consumer renders data that is current rather than merely recent.
      */
-    setArgsSource: (source: () => RequestArgs<TArgs> | null) => void;
-    /** @see SetupQueryStateOptions.devtoolsStats */
-    devtoolsStats: QueryDevtoolsStatsRecorder | null;
-    /** @see SetupQueryStateOptions.devtoolsFormLinks */
-    devtoolsFormLinks: QueryDevtoolsFormLinksRecorder | null;
-};
-type QueryState<TArgs extends QueryArgs> = {
-    rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
-    response: Signal<ResponseType<TArgs> | null>;
-    args: WritableSignal<RequestArgs<TArgs> | null>;
-    latestHttpEvent: WritableSignal<RequestHttpEvent<TArgs> | null>;
-    loading: WritableSignal<HttpRequestLoadingState | null>;
-    error: WritableSignal<QueryErrorResponse | null>;
-    lastTimeExecutedAt: WritableSignal<number | null>;
-    lastTriggeredBy: WritableSignal<string | null>;
-    executionState: Signal<QueryExecutionState<TArgs> | null>;
+    applyExternalResponse: (options: ApplyExternalResponseOptions) => boolean;
     /**
-     * A discrete, query-level stream of every request event, fed synchronously from the current
-     * request's `events$` at the moment each event occurs. Side-effect features
-     * (success/error/logging) subscribe to this instead of edge-detecting on the shared, resettable
-     * `response`/`error`/`latestHttpEvent` signals - so they cannot miss a transition when the next
-     * execution swaps the underlying request.
+     * Writes a response from a previous session - read back from the client's persisted store - onto a
+     * cache entry that has nothing of its own yet.
+     *
+     * Returns whether it was applied. It is skipped when
+     * - no entry exists for the key: the entry was destroyed again while the store was being read,
+     * - the entry's creator opted out of {@link BaseQueryCreatorOptions.persistence},
+     * - or the entry already holds a response - from its own request, or from another tab. Persisted data
+     *   only ever fills a gap; it never replaces something newer.
+     *
+     * Note that the entry's request is *not* stopped: hydration happens while it is already in flight, so
+     * persisted data is always shown alongside a revalidation rather than instead of one. An entry whose
+     * request already failed keeps its error, which is what makes the offline case honest - the data is
+     * from disk, and the attempt to refresh it did fail.
      */
-    events$: Observable<RequestHttpEvent<TArgs>>;
-    subtle: QueryStateSubtle<TArgs>;
-};
-type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
-    type: 'success';
-    response: ResponseType<TArgs>;
-};
-type QueryExecutionStateFailureWithNoResponse = {
-    type: 'failure';
-    error: QueryErrorResponse;
-    hasCachedResponse?: false;
-};
-type QueryExecutionStateFailureWithCachedResponse<TArgs extends QueryArgs> = {
-    type: 'failure';
-    error: QueryErrorResponse;
-    hasCachedResponse: true;
-    cachedResponse: ResponseType<TArgs>;
+    applyPersistedResponse: (options: ApplyPersistedResponseOptions) => boolean;
+    /** Observable stream of repository events (errors, successes, etc.) */
+    events$: Observable<QueryRepositoryEvent>;
+    /** Advanced repository internals used by the query devtools. */
+    subtle: QueryRepositorySubtle;
 };
-type QueryExecutionStateFailure<TArgs extends QueryArgs> = QueryExecutionStateFailureWithNoResponse | QueryExecutionStateFailureWithCachedResponse<TArgs>;
-type QueryExecutionStateLoadingWithNoResponse = {
-    type: 'loading';
-    hasCachedResponse: false;
-    loading: HttpRequestLoadingState;
+/** The key of a query (either a cache key for cacheable requests or a UUID for uncacheable requests) */
+type QueryKey = string;
+/** Runs .unbind() if the DestroyRef.onDestroy() gets called */
+type DestroyCleanupCallback = () => void;
+type QueryRepositoryDependencies = {
+    /** The HTTP client to use for the requests */
+    httpClient: HttpClient;
+    /** The error handler to use for the requests */
+    ngErrorHandler: ErrorHandler;
+    /** The injector to use for reactive operations like signal->observable conversions */
+    injector: Injector;
 };
-type QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = {
-    type: 'loading';
-    hasCachedResponse: true;
-    loading: HttpRequestLoadingState;
-    cachedResponse: ResponseType<TArgs>;
+type CreateQueryRepositoryConfig = CreateQueryClientConfigOptions & {
+    /** The dependencies of the query repository */
+    dependencies: QueryRepositoryDependencies;
+    /**
+     * Whether unused entries may be retained at all. `false` forces `keepUnusedFor` to `0` everywhere,
+     * regardless of client or creator configuration - used to disable retention on the server, where a
+     * per-request injector must not hold response bodies (and a pending timer) for minutes.
+     * @default true
+     */
+    retentionEnabled?: boolean;
+    /** Whether the client itself carries a retry policy, via its own `retryFn` or a feature. */
+    hasRetryPolicy?: () => boolean;
 };
-type QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithNoResponse | QueryExecutionStateLoadingWithCachedResponse<TArgs>;
-type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure<TArgs> | QueryExecutionStateLoading<TArgs>;
-declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions<TArgs>) => QueryState<TArgs>;
+/** @see CreateQueryClientConfigOptions.keepUnusedFor */
+declare const DEFAULT_KEEP_UNUSED_FOR = 300000;
+/**
+ * Hard cap on entries kept without consumers, per client. Retention is opportunistic, so a runaway
+ * count (a search-as-you-type query produces a new cache key per keystroke, and each one goes through
+ * `unbind`) must never grow unbounded - the least recently orphaned entries are dropped first.
+ */
+declare const MAX_UNUSED_ENTRIES = 50;
+declare const createQueryRepository: (config: CreateQueryRepositoryConfig) => QueryRepository;
 
 type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
     deps: QueryDependencies;
@@ -1073,6 +1092,8 @@ type QueryExecuteArgs<TArgs extends QueryArgs> = {
 type InternalQueryExecute<TArgs extends QueryArgs> = {
     (executeArgs?: QueryExecuteArgs<TArgs>): void;
     reset: () => void;
+    abort: () => boolean;
+    aborted$: Observable<void>;
     currentRepositoryKey: Signal<QueryKey | null>;
 };
 type QueryExecute<TArgs extends QueryArgs> = (executeArgs?: QueryExecuteArgs<TArgs>) => void;
@@ -1118,6 +1139,9 @@ type QueryFeature<TArgs extends QueryArgs> = {
     /** How the feature was configured, for the devtools. Only called while devtools are enabled. */
     devtools?: QueryDevtoolsFeatureDescriber;
 };
+type WithArgsQueryFeature<TArgs extends QueryArgs> = QueryFeature<TArgs> & {
+    type: typeof QueryFeatureType.WITH_ARGS;
+};
 declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
     type: QueryFeatureType | (string & {});
     fn: QueryFeatureFn<TArgs>;
@@ -1127,12 +1151,12 @@ declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
  * A query feature that allows you to set the arguments of the query.
  * The arguments are read within a computed function, so you can use reactive values.
  *
- * Return `null` to park the query: its args are reset to `null`, and polling and auto refresh
- * pause until args are set again.
+ * Return `null` to park the query: it is reset (`response()` and `executionState()` become `null`),
+ * and polling and auto refresh pause until args are set again.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
-declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | null) => QueryFeature<TArgs>;
+declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | null) => WithArgsQueryFeature<TArgs>;
 type WithPollingFeatureOptions = {
     /**
      * The interval in milliseconds at which the query should be executed. A function is read
@@ -1151,6 +1175,13 @@ type WithPollingFeatureOptions = {
      * @default false
      */
     pauseWhileHidden?: boolean;
+    /**
+     * Poll only while this returns `true`. Read reactively (pass a signal or a `computed`). While it is
+     * `false` no tick runs; when it turns `true`, a tick that fell due in between runs at once,
+     * otherwise polling resumes on its cadence.
+     * @default () => true
+     */
+    enabled?: () => boolean;
     /**
      * Execute the query when the window regains focus, and restart the interval from there.
      * @default false
@@ -1205,6 +1236,12 @@ type WithLongPollingFeatureOptions<TArgs extends QueryArgs> = {
      * @default 10
      */
     stopAfterErrors?: number;
+    /**
+     * Run the chain only while this returns `true`. Read reactively (pass a signal or a `computed`). Turning
+     * `false` aborts the round in flight and cancels a pending one; turning `true` runs that round again at once.
+     * @default () => true
+     */
+    enabled?: () => boolean;
 };
 /**
  * A query feature for long polling: a chain of requests where each round starts once the previous one
@@ -1253,6 +1290,12 @@ type WithAutoRefreshFeatureOptions = {
     onSignalChanges: Signal<unknown>[];
     /** Whether to ignore the `onlyManualExecution` query config flag */
     ignoreOnlyManualExecution?: boolean;
+    /**
+     * Refresh only while this returns `true`. Read reactively (pass a signal or a `computed`). A signal change
+     * while it is `false` is dropped - turning `true` does not execute by itself.
+     * @default () => true
+     */
+    enabled?: () => boolean;
 };
 /**
  * A query feature that will automatically execute the query when any of the provided signals change
@@ -1406,6 +1449,13 @@ type BaseQueryCreatorOptions<TArgs extends QueryArgs = QueryArgs> = {
      * @default the client's `retryFn`, else the `withDefaultRetry()` policy, else no retry
      */
     retryFn?: ShouldRetryRequestFn;
+    /**
+     * Whether a failed request is passed to Angular's `ErrorHandler`. Set to `false` when the UI already
+     * shows the error itself; `error()` and `executionState()` report the failure either way.
+     *
+     * @default true
+     */
+    reportErrors?: boolean;
     /**
      * How long (in ms) this query's cache entry is kept after its last consumer was destroyed.
      * Overrides the client level `keepUnusedFor`. Use `0` for responses that should never outlive their
@@ -1475,9 +1525,22 @@ type CreateQueryCreatorOptions<TArgs extends QueryArgs = QueryArgs> = BaseQueryC
      */
     transformResponse?: (rawResponse: RawResponseType<TArgs>) => ResponseType<TArgs>;
 });
+type QueryCreatorInput<TArgs extends QueryArgs> = readonly [QueryConfig, ...QueryFeature<TArgs>[]] | readonly QueryFeature<TArgs>[];
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type RequiresWithArgs<TArgs extends QueryArgs> = IsAny<TArgs> extends true ? false : PathParamsType<TArgs> extends {
+    [key: string]: unknown;
+} ? true : false;
+type HasWithArgsFeature<TInput extends readonly unknown[]> = number extends TInput['length'] ? true : TInput extends readonly [infer THead, ...infer TRest] ? THead extends {
+    type: typeof QueryFeatureType.WITH_ARGS;
+} ? true : HasWithArgsFeature<TRest> : false;
+type IsWithArgsErrorSilenced<TInput extends readonly unknown[]> = TInput extends readonly [infer THead, ...unknown[]] ? THead extends {
+    silenceMissingWithArgsFeatureError: true;
+} ? true : false : false;
+type MissingWithArgsError = "withArgs() is required: this query's route uses pathParams. Pass withArgs(() => ({ pathParams: … })), or set silenceMissingWithArgsFeatureError as an escape hatch.";
+type SilencedWithArgsError = 'silenceMissingWithArgsFeatureError: true is set, but withArgs() is passed. Remove one of them.';
+type WithArgsCheck<TArgs extends QueryArgs, TInput extends readonly unknown[]> = IsWithArgsErrorSilenced<TInput> extends true ? HasWithArgsFeature<TInput> extends true ? number extends TInput['length'] ? unknown : SilencedWithArgsError : unknown : RequiresWithArgs<TArgs> extends true ? HasWithArgsFeature<TInput> extends true ? unknown : MissingWithArgsError : unknown;
 type QueryCreator<TArgs extends QueryArgs> = {
-    (...features: QueryFeature<TArgs>[]): Query<TArgs>;
-    (queryConfig: QueryConfig, ...features: QueryFeature<TArgs>[]): Query<TArgs>;
+    <const TInput extends QueryCreatorInput<TArgs>>(this: WithArgsCheck<TArgs, TInput>, ...args: TInput | QueryCreatorInput<TArgs>): Query<TArgs>;
     /**
      * Creates a new query creator with merged options.
      * The new creator inherits all options from the original and overrides them with the provided options.
@@ -1536,6 +1599,12 @@ type QueryConfig = {
      * this - on a hand-written `execute()` the error it silences is a real mistake.
      */
     silenceUncacheableAllowCacheError?: boolean;
+    /**
+     * Keeps `response()` on the previous args' response while a request for new args loads, reported as
+     * `executionState().cachedResponse`. Defaults to `true` for queries that execute themselves (GET, HEAD,
+     * OPTIONS, GraphQL queries) and to `false` for mutations.
+     */
+    keepPreviousResponse?: boolean;
     /**
      * A custom injector to use for this query.
      */
@@ -2213,8 +2282,7 @@ declare const withSymfonyErrors: () => QueryClientFeatureFn;
  * a `PATCH` and a GraphQL mutation are never retried unless the options set `retryNonIdempotent`.
  *
  * The policy belongs to the client the feature is on, so another client of the same app is not
- * affected. Without it nothing is retried automatically and `error.retryState` always reads
- * `{ retry: false }`. A per-client or per-creator `retryFn` wins over it.
+ * affected. Without it nothing is retried automatically. A per-client or per-creator `retryFn` wins over it.
  *
  * @example
  * const MY_CLIENT = createQueryClient({
@@ -2469,6 +2537,8 @@ type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
     clientOptions?: CreateQueryCreatorOptions;
     /** Display name of the owning query client. Scopes devtools fault injection, which is armed per client. */
     clientName?: string;
+    /** Base URL of the owning query client, so a devtools mock pattern is matched against the route. */
+    clientBaseUrl?: string;
     /**
      * Headers configured on the query client, applied to every request it makes. Per-request
      * `args.headers` are merged on top and win per header name.
@@ -2486,6 +2556,12 @@ type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
      * @default the `withDefaultRetry()` policy, or no retry at all without that client feature
      */
     retryFn?: ShouldRetryRequestFn;
+    /**
+     * Whether `retryFn` is a policy somebody configured. Without one, `error.retryState` falls back to the
+     * built-in classification of transient failures.
+     * @default `true` when `retryFn` is set
+     */
+    hasRetryPolicy?: boolean;
     /**
      * Whether sending the request again is safe, handed to `retryFn` as `idempotent`.
      * @default `false` for a `POST` or `PATCH`, `true` for every other method
@@ -2585,7 +2661,7 @@ type HttpRequestSubtle<TArgs extends QueryArgs> = {
      */
     resolveHeaders: () => HttpHeaders | undefined;
     /**
-     * The headers the most recent execution actually went out with. Unlike {@link resolveHeaders} it
+     * The headers the most recent attempt actually went out with. Unlike {@link resolveHeaders} it
      * does not re-resolve the header providers, so after a token refresh it still reports the token
      * the request was sent with. `undefined` until the first execution.
      */
@@ -2622,8 +2698,7 @@ type HttpRequest<TArgs extends QueryArgs> = {
     url: string;
     /**
      * The args this request was built from - the resolved path params, query params, body and headers
-     * behind {@link HttpRequest.url}. Read by the query devtools to show what a query actually sent,
-     * which a query executed imperatively (`execute({ args })`) does not keep on its own `args` signal.
+     * behind {@link HttpRequest.url}. Read by the query devtools to show what a query actually sent.
      */
     args: RequestArgs<TArgs> | null;
     /**
@@ -2770,7 +2845,7 @@ type AnyNewQuery = Query<any>;
 type QuerySubtle<TArgs extends QueryArgs> = {
     /** Destroys the query and cleans up all resources. The query should not be used after this method is called. */
     destroy: () => void;
-    /** Manually sets the response of the query. This will not trigger a new execution of the query. */
+    /** Sets the response the query shows, as the consumer reads it: `transformResponse` does not run on it. Does not execute the query. */
     setResponse: (response: ResponseType<TArgs>) => void;
     /**
      * Manually forces the loading state of the query. Overridden on the next execution. Intended for
@@ -2796,12 +2871,20 @@ type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     createSnapshot: () => QuerySnapshot<TArgs>;
     /** Resets the query state to its initial state */
     reset: () => void;
+    /**
+     * Stops the execution in flight, including a retry it is waiting out, and returns whether one was.
+     * The aborted execution sets no response and no error: `response()`, `error()` and `executionState()`
+     * go back to what they were before it started (`executionState()` is `null` if the query never
+     * settled). `args()` and `lastTimeExecutedAt()` keep describing the aborted execution. The request is
+     * shared by every query bound to the same cache key, so those stop loading too.
+     */
+    abort: () => boolean;
     /** Returns a readonly version of the query */
     asReadonly: () => ReadonlyQuery<TArgs>;
     /** Advanced query features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
     subtle: QuerySubtle<TArgs>;
 };
-type ReadonlyQuery<TArgs extends QueryArgs> = Omit<Query<TArgs>, 'execute' | 'subtle' | 'reset' | 'asReadonly'>;
+type ReadonlyQuery<TArgs extends QueryArgs> = Omit<Query<TArgs>, 'execute' | 'subtle' | 'reset' | 'abort' | 'asReadonly'>;
 declare const createQuery: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => Query<TArgs>;
 
 type BaseQueryCreatorFactoryOptions<TArgs extends QueryArgs, TOptions, TInternals> = {
@@ -2900,9 +2983,10 @@ declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" |
 declare const shouldAutoExecuteGqlQuery: (method: GqlQueryMethod) => method is "QUERY";
 declare const getQueryFeatureUsage: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<any>) => QueryFeatureFlags;
 declare const applyQueryFeatures: <TArgs extends QueryArgs>(features: QueryFeature<TArgs>[], context: QueryFeatureContext<TArgs>) => void;
-declare const maybeExecute: (options: {
+declare const maybeExecute: <TArgs extends QueryArgs>(options: {
     flags: QueryFeatureFlags;
-    execute: InternalQueryExecute<any>;
+    execute: InternalQueryExecute<TArgs>;
+    state: QueryState<TArgs>;
 }) => void;
 type CreateQueryObjectOptions<TArgs extends QueryArgs> = {
     state: QueryState<TArgs>;
@@ -3213,8 +3297,9 @@ type QueryBatch<TItem, TArgs extends QueryArgs> = {
     run: (items: readonly TItem[]) => Observable<QueryBatchResult<TItem, TArgs>>;
     /**
      * Re-runs only the items that did not succeed - the failed ones plus anything left unattempted by
-     * a `cancel()` or `stopOnError`. Successful items are never sent twice, which is what makes this
-     * safe to put behind a retry button in a bulk edit. Cold, like {@link QueryBatch.run}.
+     * a `cancel()`, `stopOnError` or an unsubscribe. Successful items, and items an unsubscribe aborted
+     * in flight, are never sent twice, which is what makes this safe to put behind a retry button in a
+     * bulk edit. Cold, like {@link QueryBatch.run}.
      */
     retryFailed: () => Observable<QueryBatchResult<TItem, TArgs>>;
     /**
@@ -3223,7 +3308,7 @@ type QueryBatch<TItem, TArgs extends QueryArgs> = {
      * normal and the run emits once they do.
      *
      * Unsubscribing from the run does abort everything in flight, which for a mutation is rarely what
-     * you want. Prefer this.
+     * you want: those items stay `cancelled` and `retryFailed()` does not resend them. Prefer this.
      */
     cancel: () => void;
     /** Clears the results and returns to `idle`. Ignored while a run is in flight. */
@@ -3458,6 +3543,7 @@ declare const isSymfonyListError: (error: unknown) => error is FormViolationView
 
 declare const QueryRuntimeErrorCode: {
     readonly QUERY_FEATURE_USED_MULTIPLE_TIMES: 0;
+    readonly QUERY_CREATED_IN_REACTIVE_CONTEXT: 1;
     readonly WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION: 100;
     readonly WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 101;
     readonly WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102;
@@ -3493,6 +3579,7 @@ declare const QueryRuntimeErrorCode: {
 };
 type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
 declare const queryFeatureUsedMultipleTimes: (type: string) => RuntimeError<0>;
+declare const queryCreatedInReactiveContext: () => RuntimeError<1>;
 declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<100>;
 declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<101>;
 declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<102>;
@@ -3523,6 +3610,12 @@ declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
 declare const queryBatchAlreadyRunning: () => RuntimeError<910>;
 declare const queryBatchWithArgsUsed: () => RuntimeError<911>;
 
+/**
+ * `true` on every request `@ethlete/query` sends through `HttpClient`, so an app interceptor can skip
+ * query requests: `if (req.context.get(IS_QUERY_REQUEST)) return next(req);`.
+ */
+declare const IS_QUERY_REQUEST: HttpContextToken<boolean>;
+
 /** The last element of a tuple type - the response of the step a `.then()` callback follows. */
 type LastOf<T extends unknown[]> = T extends [...unknown[], infer L] ? L : never;
 /** The current lifecycle phase of a query sequence. */
@@ -3535,9 +3628,9 @@ type QuerySequenceStepArgs<TArgs extends QueryArgs> = {
  * The outcome of a settled {@link QuerySequence.run}.
  *
  * A discriminated union: on success `responses` is the fully-typed tuple of every step's response;
- * on failure `failedAt` is the zero-based index of the step that errored and `error` is its
- * normalized {@link QueryErrorResponse}. `snapshots` always holds the settled snapshots of every
- * step that ran - up to and including the failing one.
+ * on failure `failedAt` is the zero-based index of the step that errored or was aborted, and `error`
+ * is its normalized {@link QueryErrorResponse} - `null` for an aborted step. `snapshots` always holds
+ * the settled snapshots of every step that ran - up to and including the failing one.
  */
 type QuerySequenceResult<TResponses extends unknown[]> = {
     ok: true;
@@ -3546,7 +3639,7 @@ type QuerySequenceResult<TResponses extends unknown[]> = {
 } | {
     ok: false;
     failedAt: number;
-    error: QueryErrorResponse;
+    error: QueryErrorResponse | null;
     snapshots: AnyQuerySnapshot[];
 };
 /**
@@ -3583,7 +3676,7 @@ type QuerySequence<TResponses extends unknown[]> = {
     total: number;
     /** The query objects backing each step, in order. Useful for devtools / advanced introspection. */
     queries: AnyNewQuery[];
-    /** The error of the step that failed, or `null` while running / on success. */
+    /** The error of the step that failed, or `null` while running, on success, or when a step was aborted. */
     error: Signal<QueryErrorResponse | null>;
     /** The zero-based index of the step that failed, or `null` while running / on success. */
     failedAt: Signal<number | null>;
@@ -3606,7 +3699,8 @@ type QuerySequence<TResponses extends unknown[]> = {
      *
      * Cancellation (inherited from `executeUntilSettled`): a step whose request is cancelled - a
      * destroyed host scope, an evicted cache entry - stops the waterfall like any other failure, with
-     * an error that says the request was cancelled.
+     * an error that says the request was cancelled. A step stopped by `query.abort()` stops it too: the
+     * status is `error`, `failedAt` points at that step and `error` is `null`.
      */
     run: () => Promise<QuerySequenceResult<TResponses>>;
 };
@@ -3715,17 +3809,27 @@ type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
 declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;
 
 /**
- * Executes the query and resolves once that execution has settled (response or error received).
- * The returned snapshot is frozen to the awaited execution, so a later execution can't swap the
- * `response()` / `error()` you read from it.
+ * Executes the query on subscribe and emits once that execution has settled (response or error
+ * received), then completes. Cold: nothing is sent until it is subscribed to. The emitted snapshot is
+ * frozen to that execution, so a later execution can't swap the `response()` / `error()` you read.
  *
- * Designed for imperative flows that need a mutation's outcome in place - e.g. a signal-forms
- * `submit()` action mapping server violations onto the form via `mapViolationsToFormErrors`.
+ * Unsubscribing before it settles aborts the execution like `query.abort()`, the way unsubscribing
+ * from `HttpClient` cancels its request. An execution stopped by `query.abort()` completes the stream
+ * without a value.
  *
  * A cancelled execution settles too - the entry was evicted, unbound by a logout, or the scope that
  * owns the query was destroyed. The snapshot then reports the execution as a failure whose error
  * says the request was cancelled, and its `latestHttpEvent()` is `{ type: 'cancel' }`.
  */
+declare const executeUntilSettled$: <TArgs extends QueryArgs>(query: Query<TArgs>, executeArgs?: QueryExecuteArgs<TArgs>) => Observable<QuerySnapshot<TArgs>>;
+/**
+ * The Promise form of {@link executeUntilSettled$}, for APIs that require an `async` function - e.g. a
+ * signal-forms `submit()` action mapping server violations onto the form via
+ * `mapViolationsToFormErrors`. Executes immediately. Prefer {@link executeUntilSettled$} in RxJS code.
+ *
+ * An execution stopped by `query.abort()` resolves with a snapshot that has no response, no error, a
+ * `null` `executionState()` and `latestHttpEvent()` `{ type: 'cancel' }`.
+ */
 declare const executeUntilSettled: <TArgs extends QueryArgs>(query: Query<TArgs>, executeArgs?: QueryExecuteArgs<TArgs>) => Promise<QuerySnapshot<TArgs>>;
 
 type QueryStackSubtle<TCreator extends AnyQueryCreator, TQuery extends AnyNewQuery> = {
@@ -3886,7 +3990,7 @@ type CreateQuerySubmissionConfig<TCreator extends AnyQueryCreator, TModel> = {
     args?: (value: TModel, field: FieldTree<TModel>) => RequestArgs<QueryArgsOf<TCreator>> | null;
     /**
      * Runs after the request succeeded, before the action resolves and the form leaves its submitting
-     * state - notify, close the overlay, navigate.
+     * state - notify, close the overlay, navigate. An aborted submission does not call it.
      */
     onSuccess?: (response: ResponseType<QueryArgsOf<TCreator>>, field: FieldTree<TModel>) => void;
     /**
@@ -4038,6 +4142,11 @@ type AuthQueryConfig<TArgs extends QueryArgs> = {
      * @default (response) => response (assumes response has accessToken and refreshToken properties)
      */
     extractTokens?: (response: ResponseType<TArgs>) => BearerAuthProviderTokens;
+    /**
+     * Decides whether a failed request of this query is retried, replacing the query creator's policy.
+     * @default the query creator's `retryFn` for an authentication query, a built-in backoff for a refresh query
+     */
+    retryFn?: ShouldRetryRequestFn;
 };
 type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> & {
     /**
@@ -4062,7 +4171,7 @@ type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> &
      * Strategy for determining when to refresh the token.
      * Can be either:
      * - A percentage (0-1) of the token's lifetime (e.g., 0.75 = refresh at 75% of lifetime)
-     * - A fixed time in milliseconds before expiration
+     * - A fixed time in milliseconds before expiration (above 1; a negative number counts as 0)
      * - An object with both percentage and min/max constraints
      * @default { percentage: 0.75, minBufferMs: 60000, maxBufferMs: 600000 }
      */
@@ -4340,7 +4449,8 @@ type PersistentAuthConfig<TBuilders extends readonly AnyQueryBuilder[], TKey ext
         name?: string;
         /**
          * The domain of the cookie. If not set, the cookie is host-only: it belongs to the exact host that
-         * wrote it and no subdomain of it. Set this only when sibling subdomains must share the session.
+         * wrote it and no subdomain of it. A sibling subdomain cannot read a cookie another origin wrote, so
+         * setting this does not share a session between them.
          */
         domain?: string;
         /**
@@ -4419,6 +4529,10 @@ declare const withPersistentAuth: <TBuilders extends readonly AnyQueryBuilder[],
         value: string;
     }[];
 };
+/**
+ * Builds the `withPersistentAuth` feature against a provider's feature context. It runs in
+ * `context.injector`, so it can be called outside an injection context.
+ */
 declare const createPersistentAuthFeature: <TBuilders extends readonly AnyQueryBuilder[], TKey extends ExtractQueryKey<TBuilders[number]> = ExtractQueryKey<TBuilders[number]>>(config: PersistentAuthConfig<TBuilders, TKey>, context: BearerAuthProviderFeatureContext<unknown, TBuilders>) => PersistentAuthFeature;
 
 type TokenExpirationWarningConfig = {
@@ -4481,7 +4595,9 @@ type TokenRevocationConfig<TBuilders extends readonly AnyQueryBuilder[], TKey ex
      */
     revokeOnLogout?: boolean;
     /**
-     * The session end causes that revoke automatically. Leave it out to revoke on every cause.
+     * The session end causes that revoke automatically. Leave it out to revoke on every cause but
+     * `otherTab`. A tab that multi-tab sync logged out reads as `otherTab` here whatever the cause was, so
+     * only the tab the logout started in revokes unless this names `otherTab`.
      * @example revokeOn: ['user'] // for an API whose revocation ends the sessions on all devices
      */
     revokeOn?: readonly BearerAuthSessionEndCause[];
@@ -4494,8 +4610,8 @@ type TokenRevocationConfig<TBuilders extends readonly AnyQueryBuilder[], TKey ex
 type TokenRevocationFeature<TQuerySnapshot extends AnyQuerySnapshot> = {
     /**
      * Manually revoke the current tokens.
-     * Returns `null` if there are no tokens to revoke
-     * Returns the revocation query snapshot if revocation was attempted
+     * Returns `null` if there are no tokens to revoke, else the snapshot of the revocation that sends them -
+     * one queued behind a revocation in flight stays `isAlive()` until its own request settles.
      */
     revoke: () => TQuerySnapshot | null;
     /**
@@ -4587,6 +4703,10 @@ declare const withTracking: <TBuilders extends readonly AnyQueryBuilder[]>(confi
         value: string;
     }[];
 };
+/**
+ * Builds the `withTracking` feature against a provider's feature context. It runs in
+ * `context.injector`, so it can be called outside an injection context.
+ */
 declare const createTrackingFeature: <TBuilders extends readonly AnyQueryBuilder[]>(context: BearerAuthProviderFeatureContext<unknown, TBuilders>, config?: TrackingConfig<TBuilders>) => TrackingFeature<TBuilders>;
 
 /**
@@ -4697,8 +4817,13 @@ type BearerAuthProviderEarlySetupContext = {
      * one is a rotation, and reporting those would stomp whatever the tab is doing.
      */
     setTokens: (access: string, refresh: string) => void;
-    /** Ends the session, exactly as the provider's own `logout()` does. */
-    logout: (cause?: BearerAuthSessionEndCause) => void;
+    /**
+     * Ends the session, exactly as the provider's own `logout()` does. Pass `fromOtherTab` for a logout
+     * another tab started, so this tab does not revoke the tokens a second time.
+     */
+    logout: (cause?: BearerAuthSessionEndCause, options?: {
+        fromOtherTab?: boolean;
+    }) => void;
     /** Why the last session ended, as {@link BearerAuthProvider.sessionEndCause} reports it. */
     sessionEndCause: Signal<BearerAuthSessionEndCause | null>;
     /**
@@ -5817,8 +5942,11 @@ type QueryDevtoolsResolvedFault = {
     /** The status to fail the attempt with instead of sending it, or `null` to let it through. */
     status: number | null;
 };
-/** What a mock resolver matches against - the same three things a fault resolver sees. */
-type QueryDevtoolsMockTarget = QueryDevtoolsFaultTarget;
+/** What a mock resolver matches against - what a fault resolver sees, plus the client's base URL. */
+type QueryDevtoolsMockTarget = QueryDevtoolsFaultTarget & {
+    /** Base URL of the owning query client; the pattern is matched against the path after it. */
+    baseUrl: string;
+};
 /** The response the devtools want served instead of one upcoming attempt. */
 type QueryDevtoolsResolvedMock = {
     /** The status to respond with. `400` and above are delivered as an `HttpErrorResponse`. */
@@ -5931,8 +6059,12 @@ declare const queryDevtoolsArmedMocksRestored: Signal<boolean>;
 declare const queryDevtoolsMockId: (parts: Pick<QueryDevtoolsMock, "clientName" | "method" | "pattern"> & {
     query?: string;
 }) => string;
-/** The path of a request URL, without its origin or query string - what a pattern is matched against. */
-declare const queryDevtoolsRequestPath: (url: string) => string;
+/**
+ * The path of a request URL relative to the client's `baseUrl` (base path included), without its query
+ * string - what a pattern is matched against. A URL outside `baseUrl`, or no `baseUrl` at all, falls
+ * back to the path without its origin.
+ */
+declare const queryDevtoolsRequestPath: (url: string, baseUrl?: string) => string;
 /**
  * Whether a request carries every query parameter a mock declares. Extra parameters are ignored - a mock
  * says what the request must ask for, not everything it may.
@@ -6355,6 +6487,12 @@ declare const MAX_QUERY_DEVTOOLS_TOMBSTONES = 50;
  * for - and low, because the batch's own entry already holds every item's args, response and error.
  */
 declare const MAX_QUERY_BATCH_TOMBSTONES = 20;
+/**
+ * How many batches keep their item tombstones at all - the ones whose items settled most recently, live
+ * or destroyed. An older batch loses its whole tail, so the total stays at this times
+ * {@link MAX_QUERY_BATCH_TOMBSTONES} however many batches a page creates.
+ */
+declare const MAX_QUERY_BATCH_TOMBSTONE_BUCKETS = 5;
 /**
  * A destroyed query's last state, shaped like the query itself: every signal the panel reads is
  * replaced by a function returning the value it held when the query went away, and every action is a
@@ -6899,6 +7037,18 @@ type Sort = {
 };
 declare const transformToSort: (value: unknown) => Sort | null;
 declare const transformToSortQueryParam: (value: unknown) => string | null;
+/** One sorted column, by `key`; the same shape as the `@ethlete/components` table's `TableSort`. */
+type TableSortEntry = {
+    key: string;
+    direction: 'asc' | 'desc';
+};
+/**
+ * Reads `key:direction` entries (`name:asc`) into a table sort, dropping an entry with an empty key or an
+ * unknown direction and every repeat of a key after its first. `null` when nothing is readable.
+ */
+declare const transformToTableSort: (value: unknown) => TableSortEntry[] | null;
+/** Writes a table sort as one `key:direction` entry per sorted column. */
+declare const transformToTableSortQueryParam: (value: unknown) => string[] | null;
 
 /** @deprecated Use `queryField` with `defineQueryForm`. */
 declare class QueryField<T> {
@@ -7112,6 +7262,11 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
     entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined;
     private isDestroyed;
     private _triggeredVia;
+    private _lastExecuteCalledAt;
+    private _ownLoadExecuteTime;
+    private _responseAtExecute;
+    private _errorAtExecute;
+    private _ownLoadSettled;
     private _wasAborted;
     state$: Observable<V2QueryState<Data>>;
     constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined, 
@@ -7135,6 +7290,13 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
      * never run. The abort flag is the only thing that tells the two apart.
      */
     private toQueryState;
+    /**
+     * A load this wrapper did not start - a `refreshQueriesInUse()`, an invalidation - reports as `auto`, the way
+     * v2 reported its background refreshes. A secure query that waits for a token reports a synthetic loading
+     * state first and the request's own later, so a new load that starts before this one settled is still its own.
+     */
+    private triggerOf;
+    private hasOwnLoadSettled;
     get isExpired(): boolean | undefined;
     get isInUse(): boolean;
     get isPolling(): boolean;
@@ -8265,7 +8427,7 @@ declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "OPTIONS
  *
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
-declare const v2BuildQueryCacheKey: (route: string, args: BaseArguments | undefined, method?: Method) => string;
+declare const v2BuildQueryCacheKey: (route: string, args: (BaseArguments & WithHeaders) | undefined, method?: Method) => string;
 
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
@@ -8753,7 +8915,7 @@ declare class QueryShortNamePipe implements PipeTransform {
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
-declare const provideInfinityQueryResponseDelay: () => _angular_core.Provider[];
+declare const provideInfinityQueryResponseDelay: () => _angular_core.StaticProvider[];
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
@@ -8970,7 +9132,6 @@ declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQuer
     private cdr;
     private viewContainerRef;
     private mainTemplateRef;
-    private errorHandler;
     private injector;
     private infinityQueryResponseDelay;
     private readonly _data$;
@@ -9056,7 +9217,6 @@ type QueryDirectiveType = AnyV2Query | AnyLegacyQuery | AnyQueryCollection;
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 declare class QueryDirective<Q extends QueryDirectiveType | null> {
-    private errorHandler;
     private cdr;
     private readonly viewContext;
     query: _angular_core.InputSignal<Q>;
@@ -9194,8 +9354,7 @@ declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
  * The internal, fully-resolved definition of a single query-form field.
  *
  * Produced by the field creators (`queryField()`, `searchQueryField()`, …) and
- * consumed by `defineQueryForm()`. `T` is the field's value type and always
- * includes `null` (a field can be cleared).
+ * consumed by `defineQueryForm()`. `T` is the field's value type.
  */
 type QueryFieldDef<T> = {
     /**
@@ -9236,18 +9395,18 @@ type QueryFieldDef<T> = {
      * Exclude this field from `activeFilterCount`. The common pagination/sort/search
      * keys are excluded automatically (see `IGNORED_FILTER_COUNT_FIELDS`).
      *
-     * @default false
+     * @default false (`true` for `searchQueryField` and `sortQueryField`)
      */
     readonly skipInFilterCount?: boolean;
     /**
-     * Skip the best-effort auto-coercion (numeric strings → number, `'true'`/`'false'`
-     * → boolean, the null and empty-list sentinels → `null` and `[]`) when reading the value back from the URL.
+     * Skip the auto-coercion (a URL string read into the type of a number or boolean default, the null and
+     * empty-list sentinels → `null` and `[]`) when reading the value back from the URL.
      *
      * @default false
      */
     readonly skipAutoTransform?: boolean;
-    /** Transform a raw URL query-param value into the field's value type. */
-    readonly queryParamToValue?: (raw: unknown) => T;
+    /** Transform a raw URL query-param value into the field's value type. `null` falls back to the default. */
+    readonly queryParamToValue?: (raw: unknown) => T | null;
     /**
      * Transform the field's value into a raw URL query-param value.
      *
@@ -9451,32 +9610,72 @@ type QueryFormSignals<TFields extends QueryFormFields> = {
  */
 declare const defineQueryForm: <TFields extends QueryFormFields>(config: DefineQueryFormConfig<TFields>) => QueryFormSignals<TFields>;
 
+/** The value types the URL is read back into without a `queryParamToValue`, given a default of that type. */
+type AutoParsedValue = string | number | boolean | readonly string[];
+type ParserUnless<T, TAutoParsed> = [NonNullable<T>] extends [TAutoParsed] ? unknown : {
+    readonly queryParamToValue: (raw: unknown) => T | null;
+};
 /**
- * A generic query-form field. Defaults to `null` and, unless a transform is
- * given, relies on the auto-coercion when reading back from the URL.
+ * A generic query-form field. With a non-null `defaultValue` it is typed `T` and reads the URL back into the
+ * default's type (a number default parses numbers, a boolean default `'true'`/`'false'`); a value the type
+ * cannot hold falls back to the default. Declare `T | null` to allow an explicit `null`.
+ *
+ * Without a default it starts at `null` and reads the URL back as a string, so any other `T` needs a
+ * `queryParamToValue` - e.g. `transformToNumber`.
  *
  * @example
  * queryField<number>({ defaultValue: 1, isResetBy: ['search'] })
+ * queryField<string>()
+ * queryField<number>({ queryParamToValue: transformToNumber })
  */
-declare const queryField: <T = string>(config?: QueryFieldConfig<T | null>) => QueryFieldDef<T | null>;
+declare function queryField<T>(config: QueryFieldConfig<T> & {
+    readonly defaultValue: NonNullable<T> | (() => NonNullable<T>);
+} & ParserUnless<T, AutoParsedValue>): QueryFieldDef<T>;
+declare function queryField<T = string>(...config: [NonNullable<T>] extends [string] ? [config?: QueryFieldConfig<T | null>] : [config: QueryFieldConfig<T | null> & ParserUnless<T | null, string>]): QueryFieldDef<T | null>;
 /**
- * A debounced free-text search field. Debounces typing by 300ms but applies
- * clearing immediately (`disableDebounceIfFalsy`). Reads the URL value back as the raw string.
+ * A debounced free-text search field, typed `string` like every text control; `''` is empty and writes no
+ * URL param. Debounces typing by 300ms but applies clearing immediately (`disableDebounceIfFalsy`). Not counted
+ * by `activeFilterCount`, whatever its key.
  */
-declare const searchQueryField: (config?: QueryFieldConfig<string | null>) => QueryFieldDef<string | null>;
+declare const searchQueryField: (config?: QueryFieldConfig<string>) => QueryFieldDef<string>;
 /**
- * A sort field serialized as `"active:direction"` (e.g. `"name:asc"`). Matches
- * the wire format the table system's URL adapter uses, so the two interoperate.
+ * A sort field serialized as `"active:direction"` (e.g. `"name:asc"`). Not counted by `activeFilterCount`,
+ * whatever its key.
  */
 declare const sortQueryField: (config?: QueryFieldConfig<Sort | null>) => QueryFieldDef<Sort | null>;
+/**
+ * A multi-column sort typed like the `@ethlete/components` table's `sort`, so `[(sort)]` binds it with no
+ * mapping. Written as one `key:direction` param per column (`?sort=name:asc&sort=date:desc`); an unreadable
+ * entry is dropped. Starts at `[]`. Not counted by `activeFilterCount`, whatever its key.
+ *
+ * @example
+ * tableSortQueryField() // <et-table [(sort)]="qf.fields.sort().value" sortMode="server" />
+ */
+declare const tableSortQueryField: (config?: QueryFieldConfig<TableSortEntry[]>) => QueryFieldDef<TableSortEntry[]>;
 /** A field holding a list of strings. */
 declare const stringArrayQueryField: (config?: QueryFieldConfig<string[] | null>) => QueryFieldDef<string[] | null>;
 /** A field holding a list of numbers. */
 declare const numberArrayQueryField: (config?: QueryFieldConfig<number[] | null>) => QueryFieldDef<number[] | null>;
 /** A field holding a list of booleans. */
 declare const booleanArrayQueryField: (config?: QueryFieldConfig<boolean[] | null>) => QueryFieldDef<boolean[] | null>;
-/** A single date field (expects an ISO/`Date`-parseable string in the URL). */
-declare const dateQueryField: (config?: QueryFieldConfig<Date | null>) => QueryFieldDef<Date | null>;
+/** Options of {@link dateQueryField}; `as: 'string'` keeps the control's wire string instead of a `Date`. */
+type DateQueryFieldConfig = QueryFieldConfig<Date | null> & {
+    readonly as?: 'date';
+};
+/** Options of {@link dateQueryField} with `as: 'string'`. */
+type DateStringQueryFieldConfig = QueryFieldConfig<string | null> & {
+    readonly as: 'string';
+};
+/**
+ * A single date field. By default it holds a `Date` read from an ISO/`Date`-parseable string in the URL.
+ * `as: 'string'` types it `string | null` like the `@ethlete/components` date and time controls, so
+ * `[formField]` binds it to them; the URL then carries the control's `valueFormat` string verbatim.
+ *
+ * @example
+ * dateQueryField({ as: 'string' }) // <et-date-input [formField]="qf.fields.from" valueFormat="yyyy-MM-dd" />
+ */
+declare function dateQueryField(config: DateStringQueryFieldConfig): QueryFieldDef<string | null>;
+declare function dateQueryField(config?: DateQueryFieldConfig): QueryFieldDef<Date | null>;
 /** A field holding a list of dates. */
 declare const dateArrayQueryField: (config?: QueryFieldConfig<Date[] | null>) => QueryFieldDef<Date[] | null>;
 
@@ -9525,10 +9724,16 @@ type WebSocketClientSocket = {
     connect: () => void;
     disconnect: () => void;
     emit: (event: string, data: unknown) => void;
-    on: (event: 'connect' | 'disconnect', listener: () => void) => void;
+    on: {
+        (event: 'connect', listener: () => void): void;
+        (event: 'disconnect', listener: (reason: string) => void): void;
+        (event: 'connect_error', listener: (error: Error) => void): void;
+    };
     onAny: (listener: (eventName: string, ...args: unknown[]) => void) => void;
     onAnyOutgoing: (listener: (eventName: string, ...args: unknown[]) => void) => void;
     readonly recovered: boolean;
+    /** `false` once socket.io gave up reconnecting on its own - after a rejected handshake, for example. */
+    readonly active?: boolean;
 };
 /**
  * The `io` factory of `socket.io-client`, declared structurally.
@@ -9625,7 +9830,7 @@ type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageVi
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
 /** The version of `@ethlete/query` this build was cut from. */
-declare const QUERY_VERSION = "6.0.0-next.51";
+declare const QUERY_VERSION = "6.0.0-next.53";
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryHeaders, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapGqlResponseWithErrors, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, AuthGuardPermission, AuthGuardPermissionOptions, AuthGuardTarget, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthActivityCoordination, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSession, BearerAuthSessionAdoption, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryBatchOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySubmissionConfig, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlDataWithErrors, GqlEnvelope, GqlError, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlRawResponseType, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpCancelEvent, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryBatch, QueryBatchDevtoolsHandle, QueryBatchItemCancelled, QueryBatchItemError, QueryBatchItemResult, QueryBatchItemSkipped, QueryBatchItemSuccess, QueryBatchResult, QueryBatchStatus, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsApiEnv, QueryDevtoolsApiEnvSwitch, QueryDevtoolsAppInfo, QueryDevtoolsAuthAccount, QueryDevtoolsAuthAccountView, QueryDevtoolsAuthField, QueryDevtoolsAuthLocalAccount, QueryDevtoolsAuthProviderHandle, QueryDevtoolsAuthProviderRegistration, QueryDevtoolsAuthQuery, QueryDevtoolsAuthSeed, QueryDevtoolsAuthSession, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateFailureWithCachedResponse, QueryExecutionStateFailureWithNoResponse, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormBranchWriteOptions, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormPersistence, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormStorage, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryHeaders, QueryHeadersInput, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockHoldOptions, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubmissionRef, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientAuth, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, IS_QUERY_REQUEST, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_BATCH_TOMBSTONE_BUCKETS, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, executeUntilSettled$, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryCreatedInReactiveContext, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, recordExecutionArgs, registerEthleteVersion, registerQueryErrorParser, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryHeaders, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, tableSortQueryField, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, transformToTableSort, transformToTableSortQueryParam, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapGqlResponseWithErrors, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, AuthGuardPermission, AuthGuardPermissionOptions, AuthGuardTarget, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthActivityCoordination, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSession, BearerAuthSessionAdoption, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryBatchOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySubmissionConfig, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DateQueryFieldConfig, DateStringQueryFieldConfig, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlDataWithErrors, GqlEnvelope, GqlError, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlRawResponseType, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpCancelEvent, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryBatch, QueryBatchDevtoolsHandle, QueryBatchItemCancelled, QueryBatchItemError, QueryBatchItemResult, QueryBatchItemSkipped, QueryBatchItemSuccess, QueryBatchResult, QueryBatchStatus, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryCreator, QueryCreatorInput, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsApiEnv, QueryDevtoolsApiEnvSwitch, QueryDevtoolsAppInfo, QueryDevtoolsAuthAccount, QueryDevtoolsAuthAccountView, QueryDevtoolsAuthField, QueryDevtoolsAuthLocalAccount, QueryDevtoolsAuthProviderHandle, QueryDevtoolsAuthProviderRegistration, QueryDevtoolsAuthQuery, QueryDevtoolsAuthSeed, QueryDevtoolsAuthSession, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateFailureWithCachedResponse, QueryExecutionStateFailureWithNoResponse, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormBranchWriteOptions, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormPersistence, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormStorage, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryHeaders, QueryHeadersInput, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockHoldOptions, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubmissionRef, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TableSortEntry, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientAuth, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithArgsCheck, WithArgsQueryFeature, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };