@ethlete/query 6.0.0-next.27 → 6.0.0-next.29

package/types/ethlete-query.d.ts

@@ -211,6 +211,8 @@ type QueryExecuteOptions<TArgs extends QueryArgs> = {
     args: RequestArgs<TArgs> | null;
     options?: RunQueryExecuteOptions;
     isSecure?: boolean;
+    /** @see QueryRepositoryRequestOptions.isRefreshable */
+    isRefreshable?: boolean;
 };
 declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
 declare const circularQueryDependencyChecker: () => {
@@ -233,6 +235,12 @@ type QueryRefreshCause = {
     /** 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;
@@ -285,6 +293,22 @@ type QueryRepositoryEvent = {
     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
@@ -320,6 +344,12 @@ type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
     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`.
+     */
+    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) */
@@ -516,8 +546,14 @@ type JsonPath = (string | number)[];
  * whole body, which is what lets it survive a refetch that returns a differently-valued but same-shaped
  * response.
  *
- * `reset` is never stored or replayed - arming one clears the other ops already armed at its exact path
- * instead, so the panel's "reset this value" action and its "arm an edit" actions share one entry point.
+ * `reset` is never stored or replayed - arming one clears the other ops already armed at its path or
+ * anywhere below it instead, so the panel's "reset this value" action and its "arm an edit" actions
+ * share one entry point. Resetting a container therefore undoes a "fill recursively" run, whose ops
+ * sit on the leaves rather than on the container itself.
+ *
+ * On the preset ops, `custom` - when present - is the exact value replayed, and `preset` is only the
+ * label it was generated under. Values are generated once at arm time and stored, never re-rolled
+ * inside apply, so a refetch replays the same response instead of reshuffling it.
  */
 type OverrideOp = {
     type: 'set';
@@ -526,7 +562,7 @@ type OverrideOp = {
 } | {
     type: 'stringPreset';
     path: JsonPath;
-    preset: 'short' | 'long' | 'unicode' | 'custom';
+    preset: 'short' | 'long' | 'longWord' | 'unicode' | 'custom';
     custom?: string;
 } | {
     type: 'numberPreset';
@@ -573,11 +609,16 @@ type QueryDevtoolsOverridesHandle = {
 /** The write side, used by the instrumentation inside the query itself. */
 type QueryDevtoolsOverridesRecorder = QueryDevtoolsOverridesHandle & {
     /**
-     * Arms a new op, or - for `{ type: 'reset' }` - disarms whatever op(s) already sit at that exact path
-     * instead of adding one.
+     * Arms a new op, or - for `{ type: 'reset' }` - disarms whatever op(s) already sit at that path or
+     * below it instead of adding one.
      */
     arm: (op: OverrideOp) => void;
 };
+/**
+ * Whether any of `entries` is armed at `path` or anywhere below it - what the panel's menu asks before
+ * offering "Reset", so the destructive action is hidden where it would be a silent no-op.
+ */
+declare const hasQueryDevtoolsOverridesAtPath: (entries: readonly QueryDevtoolsOverrideEntry[], path: JsonPath) => boolean;
 /**
  * Clones `item` (a plain object array element) with every identity-shaped field replaced by a fresh
  * value, so a duplicated row never collides with the one it was copied from. A field counts as identity
@@ -610,6 +651,20 @@ declare const isDateShapedLeaf: (key: string | number | null, value: unknown) =>
  * op list with the exact same walk the docs describe, rather than a second, possibly-drifted one.
  */
 declare const collectLeafPaths: (value: unknown, kind: "string" | "number" | "boolean") => JsonPath[];
+/**
+ * Generates a fresh sample value for a string preset, so filling twenty fields yields twenty different
+ * values instead of twenty identical ones. Call it at arm time and store the result in the op's
+ * `custom` field - generating inside apply would reshuffle the response on every refetch. `longWord`
+ * is a single unbreakable token (a compound word, a URL, a hex blob) - it tests overflow, where
+ * `long` tests wrapping.
+ */
+declare const generateQueryDevtoolsStringPreset: (preset: "short" | "long" | "longWord" | "unicode") => string;
+/**
+ * Generates a fresh sample value for a number preset - same arm-time contract as
+ * {@link generateQueryDevtoolsStringPreset}. `negative` and `huge` vary in magnitude so a batch fill
+ * produces varied digit counts; `zero` is always `0`.
+ */
+declare const generateQueryDevtoolsNumberPreset: (preset: "zero" | "negative" | "huge") => number;
 /**
  * Replays `entries` against `raw`, in order, and reports which ones no longer resolve. Shared by the
  * pipeline (which only needs {@link value}) and the panel's menu (which previews a value and marks stale
@@ -681,6 +736,24 @@ type QueryDevtoolsPayload = {
  * 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".
@@ -722,6 +795,8 @@ type QueryDevtoolsRun = {
     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 = {
@@ -744,7 +819,10 @@ type QueryDevtoolsStatsRecorder = QueryDevtoolsStatsHandle & {
     }) => 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
@@ -754,6 +832,14 @@ type QueryDevtoolsStatsRecorder = QueryDevtoolsStatsHandle & {
         attempt: number;
     }) => void;
 };
+/**
+ * How many bodies each query retains - {@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.
@@ -1084,6 +1170,9 @@ type BaseQueryCreatorOptionsSubtle = {
      * - `true` means the request will always be cached
      * - `false` means the request will never be cached
      * - `undefined` means the request will be cached if the method is GET, OPTIONS or HEAD
+     *
+     * This says nothing about whether the request may be re-run: `refreshQueriesInUse()` and
+     * `invalidateQueries()` still only fire reads.
      */
     useQueryRepositoryCache?: boolean;
 };
@@ -2056,8 +2145,9 @@ type QueryClient = {
      * the new value only affects *subsequent* requests, so anything already resolved keeps data
      * fetched under the old one until this is called.
      *
-     * Only cacheable requests are refreshed: re-firing a mutation nobody asked for would be a far worse
-     * surprise than a stale read.
+     * Only reads are refreshed - `GET`/`HEAD`/`OPTIONS` and GraphQL queries transported via `POST`:
+     * re-firing a mutation nobody asked for would be a far worse surprise than a stale read. A `POST`
+     * that merely opted into the repository cache stays untouched.
      *
      * @see QueryClient.invalidateQueries for the case where the *data* went stale rather than the
      * request, which is the one that also concerns the user's other tabs.
@@ -2076,7 +2166,7 @@ type QueryClient = {
      * client.invalidateQueries({ url: '/players' }); // /players, /players/1, /players?page=2
      * client.invalidateQueries(); // everything on screen, here and in the other tabs
      *
-     * Same set as {@link QueryClient.refreshQueriesInUse}: cacheable entries with at least one
+     * Same set as {@link QueryClient.refreshQueriesInUse}: reads with at least one
      * consumer, cache bypassed, in-flight requests restarted. Entries sitting out their `keepUnusedFor`
      * window are deliberately left alone - they revalidate on their own when a consumer binds again,
      * and refreshing what nobody is looking at is how an invalidation turns into a request storm.
@@ -2595,6 +2685,10 @@ type CreatePagedQueryStackOptions<TArgs extends QueryArgs, TNormPagination exten
     /**
      * If true, no queries will be executed while the paged query is loading.
      * This is useful if you need the current response to be used in the next query.
+     *
+     * This governs the `fetchNextPage()` / `fetchPreviousPage()` methods only. The
+     * `canFetchNextPage` / `canFetchPreviousPage` signals are `false` while any page loads either way,
+     * so a UI bound to them never issues the concurrent call this option would allow.
      */
     blockExecutionDuringLoading?: boolean;
 };
@@ -3221,8 +3315,10 @@ type CreateQueryStackOptions<TCreator extends AnyQueryCreator, TDeps extends ()
     };
     /**
      * Transforms the responses of all queries in the stack. Useful for merging or filtering responses.
+     * A response is `null` while its query is loading or errored, so a transform runs on nulls before
+     * anything has settled.
      */
-    transform?: (responses: ResponseType<QueryArgsOf<TCreator>>[]) => TTransform;
+    transform?: (responses: (ResponseType<QueryArgsOf<TCreator>> | null)[]) => TTransform;
     /**
      * If true, prevents creating queries with identical args.
      * Useful for append mode to avoid duplicate data fetching.
@@ -3327,6 +3423,12 @@ type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
     authProvider: AnyBearerAuthProvider;
     deps: QueryDependencies;
     state: QueryState<TArgs>;
+    /**
+     * Whether the query runs itself rather than only on an explicit `execute()` - the same condition
+     * `maybeExecute` and the `withArgs` feature use. Only those are re-run once a new session starts;
+     * re-firing a mutation on the next login would repeat it behind the user's back.
+     */
+    autoExecutes: boolean;
     transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> | undefined, tokens: {
         accessToken: string;
     }, headers: HttpHeaders, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
@@ -3377,8 +3479,13 @@ type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> &
         maxBufferMs?: number;
     };
     /**
-     * Minimum interval between refresh attempts in milliseconds.
+     * Minimum interval between the *proactive* refreshes the expiry timer schedules, in milliseconds.
      * Prevents rapid refresh loops in case of issues.
+     *
+     * A refresh a 401 asked for is never throttled by this - a token revoked seconds after a proactive
+     * refresh is exactly when the request must go out. Those are deduplicated instead: one refresh is
+     * in flight at a time.
+     *
      * @default 30000 (30 seconds)
      */
     minRefreshInterval?: number;
@@ -3416,6 +3523,34 @@ type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> &
      * @default true
      */
     autoRetryOn401?: boolean;
+    /**
+     * What to do once the refresh query has failed for good - `retryConfig` decides what is retried,
+     * this decides what a failure that survived it means.
+     *
+     * Defaults to ending the session for any status `retryConfig.retryableStatusCodes` does not list:
+     * those are the failures that could still succeed later, everything else leaves the tab holding a
+     * token the server will not renew. Without this the session would look valid while every secure
+     * query 401s.
+     *
+     * @example
+     * withRefreshQuery('refresh', {
+     *   queryCreator: refresh,
+     *   onRefreshFailure: ({ error, logout }) => {
+     *     if (error.code !== 503) logout();
+     *   },
+     * });
+     */
+    onRefreshFailure?: (failure: RefreshFailure) => void;
+};
+/** What {@link TokenRefreshQueryConfig.onRefreshFailure} is handed when a refresh gives up. */
+type RefreshFailure = {
+    /** The error the refresh query ended on. */
+    error: QueryErrorResponse;
+    /**
+     * Ends the session, exactly as the provider's own `logout()` does, reporting `sessionEndCause`
+     * as `'expired'`.
+     */
+    logout: () => void;
 };
 type AuthQueryBuilder<TKey extends string, TArgs extends QueryArgs> = {
     _type: 'authQuery';
@@ -3483,8 +3618,9 @@ declare const withInactivityLogout: <TBuilders extends readonly AnyQueryBuilder[
 
 type BearerAuthMultiTabSyncConfig = {
     /**
-     * Channel name for BroadcastChannel
-     * @default 'ethlete-auth-sync'
+     * Channel name for BroadcastChannel. Defaults to a channel of the provider's own, so two providers
+     * reachable from the same origin do not sync each other's sessions.
+     * @default `ethlete-auth-sync:<provider name>`
      */
     channelName?: string;
     /**
@@ -3730,6 +3866,9 @@ type QueryFailureEventData = {
 type TokenRefreshEventData = {
     automatic: boolean;
 };
+type LogoutEventData = {
+    cause: BearerAuthSessionEndCause | null;
+};
 type LeaderStatusChangeEventData = {
     isLeader: boolean;
 };
@@ -3737,7 +3876,7 @@ type LeaderInstanceCountChangeEventData = {
     count: number;
 };
 type TrackingEventDataMap<TBuilders extends readonly AnyQueryBuilder[]> = {
-    [K in TrackingEventName<TBuilders>]: K extends `${string}Execute` ? QueryExecuteEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Success` ? QuerySuccessEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Failure` ? QueryFailureEventData : K extends 'tokenRefreshSuccess' ? TokenRefreshEventData : K extends 'logout' ? void : K extends 'leaderStatusChange' ? LeaderStatusChangeEventData : K extends 'leaderInstanceCountChange' ? LeaderInstanceCountChangeEventData : never;
+    [K in TrackingEventName<TBuilders>]: K extends `${string}Execute` ? QueryExecuteEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Success` ? QuerySuccessEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Failure` ? QueryFailureEventData : K extends 'tokenRefreshSuccess' ? TokenRefreshEventData : K extends 'logout' ? LogoutEventData : K extends 'leaderStatusChange' ? LeaderStatusChangeEventData : K extends 'leaderInstanceCountChange' ? LeaderInstanceCountChangeEventData : never;
 };
 type TrackingEventHandler<TData> = (data: TData) => void;
 type TrackingConfig<TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[]> = {
@@ -3797,6 +3936,28 @@ type BearerAuthExecutionStateTokenSeed = {
     state: 'success';
 };
 type BearerAuthExecutionState<TType extends string = string> = BearerAuthExecutionStateLoading<TType> | BearerAuthExecutionStateSuccess<TType> | BearerAuthExecutionStateError<TType> | BearerAuthExecutionStateLogout | BearerAuthExecutionStateTokenSeed;
+/**
+ * Whether this tab has a session, and whether it is still finding out.
+ *
+ * - `unknown` - the provider has not finished its own startup yet. Never observed from a component.
+ * - `restoring` - a session restore is in flight (`withPersistentAuth`'s auto-login).
+ * - `authenticated` - tokens are applied.
+ * - `anonymous` - no session, and nothing is trying to get one.
+ */
+type BearerAuthSessionStatus = 'unknown' | 'restoring' | 'authenticated' | 'anonymous';
+/**
+ * Why the session ended. A user-initiated logout must stay put; a session that ended on its own
+ * usually returns the user to where they were, so the two cannot be told apart by state alone.
+ */
+type BearerAuthSessionEndCause = 
+/** `logout()` called with no cause - a user clicking "log out". */
+'user'
+/** `withInactivityLogout`'s timer elapsed. */
+ | 'inactivity'
+/** A token refresh failed for good, so the tab can no longer renew the session. */
+ | 'expired'
+/** Another tab logged out and `withBearerAuthMultiTabSync` carried it here. */
+ | 'otherTab';
 declare const BearerAuthFeatureType: {
     readonly PERSISTENT_AUTH: "PERSISTENT_AUTH";
     readonly TOKEN_EXPIRATION_WARNING: "TOKEN_EXPIRATION_WARNING";
@@ -3813,8 +3974,9 @@ type BearerAuthFeature<TBuilders extends readonly AnyQueryBuilder[], TBearerData
     devtools?: QueryDevtoolsFeatureDescriber;
 };
 /**
- * What a feature gets before the provider's queries are wired up. Only the tokens and the client
- * exist this early - everything else is built on top of what early setup returns.
+ * What a feature gets before the provider's queries are wired up. Only the tokens, the client and the
+ * two session entry points exist this early - everything else is built on top of what early setup
+ * returns.
  *
  * Advanced: only a feature that has to run before the auth queries are wired needs this.
  */
@@ -3822,6 +3984,29 @@ type BearerAuthProviderEarlySetupContext = {
     accessToken: WritableSignal<string | null>;
     refreshToken: WritableSignal<string | null>;
     queryClient: QueryClient;
+    /**
+     * The provider's own name. A feature that reaches outside the tab - a `BroadcastChannel`, a Web Lock,
+     * a storage key - must namespace it with this, or two providers on the same origin share it.
+     */
+    name: string;
+    /**
+     * Applies a token pair the way a successful auth query does - including the `afterTokenRefresh$`
+     * emission that retries secure queries which failed with a 401. Prefer this over writing
+     * {@link accessToken} and {@link refreshToken}, which only changes what the next request sends.
+     */
+    applyTokens: (access: string, refresh: string) => void;
+    /** Ends the session, exactly as the provider's own `logout()` does. */
+    logout: (cause?: BearerAuthSessionEndCause) => void;
+};
+/**
+ * How a tab that is not the leader gets a refresh out of the tab that is. Contributed by
+ * `withBearerAuthMultiTabSync`; absent when every tab refreshes for itself.
+ */
+type BearerAuthRefreshCoordination = {
+    /** Asks the leader tab to refresh the session's tokens now. */
+    request: () => void;
+    /** Emits in the leader tab whenever another tab asked for a refresh. */
+    requests$: Observable<void>;
 };
 /** The parts of the provider an early setup can contribute. */
 type BearerAuthProviderEarlySetupResult = {
@@ -3830,6 +4015,7 @@ type BearerAuthProviderEarlySetupResult = {
         isLeader: Signal<boolean>;
         instanceCount: Signal<number>;
     };
+    refreshCoordination?: BearerAuthRefreshCoordination;
 };
 /**
  * A feature builder that additionally runs before the auth queries are set up. The auth queries read
@@ -3943,6 +4129,17 @@ type BearerAuthProvider<TBuilders extends readonly AnyQueryBuilder[], TFeatures
      * Tracks the latest auth operation (login, autoLogin, tokenRefresh, logout, revocation) with its state and payload.
      */
     executionState: Signal<BearerAuthExecutionState<ExtractQueryKey<TBuilders[number]> | 'autoLogin' | 'tokenRefresh' | 'logout' | 'revocation' | 'tokenSeed'> | null>;
+    /**
+     * Whether this tab has a session, and whether it is still finding out - the signal to gate an app
+     * shell on. Unlike {@link executionState} it always has a value, it answers only this one question,
+     * and it reaches `anonymous` even when nothing ever executed (no cookie to restore from).
+     */
+    sessionStatus: Signal<BearerAuthSessionStatus>;
+    /**
+     * Why the last session ended, or `null` while one is running and before the first ever ended.
+     * Cleared as soon as tokens are applied again.
+     */
+    sessionEndCause: Signal<BearerAuthSessionEndCause | null>;
     /**
      * Seeds the provider with tokens that were issued outside of it - an SSO/OIDC callback that
      * arrives with both tokens in the URL, a token handed over by a native shell, a test harness.
@@ -3958,9 +4155,10 @@ type BearerAuthProvider<TBuilders extends readonly AnyQueryBuilder[], TFeatures
      */
     setTokens: (accessToken: string, refreshToken: string) => void;
     /**
-     * Logout the user (clears all tokens and unbinds secure queries)
+     * Logout the user (clears all tokens and unbinds secure queries). The optional cause is published
+     * as {@link sessionEndCause}; it defaults to `'user'`, so a plain `logout()` reads as a click.
      */
-    logout: () => void;
+    logout: (cause?: BearerAuthSessionEndCause) => void;
     /**
      * Observable that emits after a successful token refresh.
      * Secure queries can subscribe to this to re-execute themselves with the new token.
@@ -3972,7 +4170,7 @@ type BearerAuthProviderFeatureContext<TBearerData = unknown, TBuilders extends r
     afterTokenRefresh$: Observable<void>;
     accessToken: WritableSignal<string | null>;
     bearerData: Signal<TBearerData | null>;
-    logout: () => void;
+    logout: (cause?: BearerAuthSessionEndCause) => void;
     injector: Injector;
     destroyRef: DestroyRef;
     setTokens: (access: string, refresh: string) => void;
@@ -3983,6 +4181,8 @@ type BearerAuthProviderFeatureContext<TBearerData = unknown, TBuilders extends r
     };
     queries: QueryRegistry<TBuilders>;
     executionState: WritableSignal<BearerAuthExecutionState | null>;
+    sessionStatus: Signal<BearerAuthSessionStatus>;
+    sessionEndCause: Signal<BearerAuthSessionEndCause | null>;
 };
 type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[]> = {
     accessToken: WritableSignal<string | null>;
@@ -3992,7 +4192,12 @@ type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends rea
     repository: QueryRepository;
     afterTokenRefresh$: Observable<void>;
     isLeader: () => boolean;
+    refreshCoordination: BearerAuthRefreshCoordination | undefined;
+    /** Ends the session, exactly as the provider's own `logout()` does. */
+    logout: (cause?: BearerAuthSessionEndCause) => void;
     queries: QueryRegistry<TBuilders>;
+    /** Whether any execution that can issue tokens is still running, across every registry key. */
+    hasTokenIssuingExecutionInFlight: Signal<boolean>;
 };
 declare const createBearerAuthProvider: <TBuilders extends readonly AnyQueryBuilder[], TFeatures extends readonly ((context: BearerAuthProviderFeatureContext<TBearerData, TBuilders>) => unknown)[], TBearerData = unknown>(config: CreateBearerAuthProviderConfig<TBuilders, TFeatures, TBearerData>) => ProviderDefinition<BearerAuthProvider<TBuilders, TFeatures, TBearerData>>;
 type BearerAuthProviderRef<TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[], TFeatures extends readonly ((context: BearerAuthProviderFeatureContext<TBearerData, TBuilders>) => unknown)[] = readonly ((context: BearerAuthProviderFeatureContext<unknown, readonly AnyQueryBuilder[]>) => unknown)[], TBearerData = unknown> = ProviderDefinition<BearerAuthProvider<TBuilders, TFeatures, TBearerData>>;
@@ -4212,6 +4417,14 @@ type QueryDevtoolsEntry = {
     meta: QueryDevtoolsEntryMeta;
     handle: unknown;
     createdAt: number;
+    /**
+     * When the query behind this entry was destroyed, or `null`/absent while it is still live. A
+     * destroyed entry is kept as a tombstone - a frozen snapshot of what the query last held - so a
+     * request that failed on the way out (a `401` that redirects to login and takes its component with
+     * it) is still readable by the time the panel is opened. Its `handle` answers with constants and
+     * every action on it is inert.
+     */
+    destroyedAt?: number | null;
     /**
      * What the entry has done since it was created - executions, requests, payload sizes. Present for
      * queries; stacks, sequences and auth providers aggregate the stats of the queries they own instead.
@@ -4281,6 +4494,19 @@ type QueryDevtoolsResolvedFault = {
 declare const queryDevtoolsEntries: Signal<QueryDevtoolsEntry[]>;
 /** Renders parsed route parts as a template, e.g. `/team/:teamId/players`. */
 declare const stringifyQueryRouteParts: (parts: QueryDevtoolsRoutePart[]) => string;
+/**
+ * Forgets every destroyed entry the registry is holding - the panel's "clear gone" action. Live
+ * entries are untouched.
+ */
+declare const clearQueryDevtoolsTombstones: () => void;
+type QueryDevtoolsOptions = {
+    /**
+     * How many of each query's most recent runs keep their response (or error) body, which is what the
+     * panel's response diff compares. Defaults to `5`. Bodies dominate what the run buffer retains, so
+     * raise this only as far as the reach you actually need - a polling query holds one per run.
+     */
+    responseHistory?: number;
+};
 /**
  * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
  * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
@@ -4296,7 +4522,33 @@ declare const stringifyQueryRouteParts: (parts: QueryDevtoolsRoutePart[]) => str
  * });
  * ```
  */
-declare const provideQueryDevtools: () => EnvironmentProviders;
+declare const provideQueryDevtools: (options?: QueryDevtoolsOptions) => EnvironmentProviders;
+
+/**
+ * How many destroyed queries the registry keeps. A tombstone holds the last response body it captured,
+ * so the list is capped for the same reason the repository caps its unused entries.
+ */
+declare const MAX_QUERY_DEVTOOLS_TOMBSTONES = 50;
+/**
+ * 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
+ * no-op. Rendering a tombstone therefore costs the panel no second code path - the drawer reads
+ * `entry.handle` exactly as it does for a live query, and gates its actions on
+ * {@link QueryDevtoolsEntry.destroyedAt} instead.
+ *
+ * The captured request is a plain copy, not the request itself: the real one is destroyed the moment
+ * its cache entry is, and holding it would keep its subscriptions and its cache entry alive.
+ */
+declare const snapshotQueryDevtoolsHandle: (handle: unknown) => unknown;
+/**
+ * The entry a destroyed query leaves behind: the same id, kind and metadata, a frozen
+ * {@link snapshotQueryDevtoolsHandle} in place of the live query, and no `element` - a DOM node whose
+ * component is gone must not be kept alive by the panel.
+ *
+ * `stats` is carried over as-is. The recorder closes over its own signals rather than over the query,
+ * so the run history that makes a failed request readable survives without retaining anything.
+ */
+declare const tombstoneOf: (entry: QueryDevtoolsEntry, destroyedAt: number) => QueryDevtoolsEntry;
 
 type TransformedGqlQuery = {
     query: string;
@@ -7006,7 +7258,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 `createQueryForm()`. `T` is the field's value type and always
+ * consumed by `defineQueryForm()`. `T` is the field's value type and always
  * includes `null` (a field can be cleared).
  */
 type QueryFieldDef<T> = {
@@ -7081,7 +7333,7 @@ type QueryFieldConfig<T> = Partial<Omit<QueryFieldDef<T>, 'isResetBy'>> & {
 };
 /** Extracts a field definition's value type. */
 type QueryFieldValue<F> = F extends QueryFieldDef<infer T> ? T : never;
-/** A map of field name → field definition, as passed to `createQueryForm({ fields })`. */
+/** A map of field name → field definition, as passed to `defineQueryForm({ fields })`. */
 type QueryFormFields = Record<string, QueryFieldDef<unknown>>;
 /** The value shape of a query form - one entry per field. */
 type QueryFormModel<TFields extends QueryFormFields> = {
@@ -7152,7 +7404,7 @@ type QueryFormBranch<TFields extends QueryFormFields> = {
     resetFieldToDefault(key: keyof QueryFormModel<TFields>): void;
     resetAllFieldsToDefault(): void;
 };
-type CreateQueryFormConfig<TFields extends QueryFormFields> = {
+type DefineQueryFormConfig<TFields extends QueryFormFields> = {
     readonly fields: TFields;
     /**
      * A prefix for every query-param key, so multiple query forms can coexist on
@@ -7172,34 +7424,9 @@ type CreateQueryFormConfig<TFields extends QueryFormFields> = {
  * debounced committed value, syncs to the URL query params, and resets dependent
  * fields via the `isResetBy` graph - all as signals.
  *
- * @example
- * const qf = createQueryForm({
- *   fields: {
- *     search: searchQueryField(),
- *     sort: sortQueryField(),
- *     page: queryField<number>({ defaultValue: 1, isResetBy: ['search', 'sort'] }),
- *   },
- * }).observe();
- * // template: <input etInput [formField]="qf.fields.search" />
+ * Created with {@link defineQueryForm}.
  */
-declare class QueryFormSignals<TFields extends QueryFormFields> {
-    private router;
-    private route;
-    private injector;
-    private readonly queryParamChanges;
-    private readonly _fields;
-    private readonly prefix;
-    private readonly defaults;
-    /** Live field values (updated immediately by bound controls). */
-    private readonly model;
-    /** The committed (debounced) value that drives `value`, the URL and the filter count. */
-    private readonly committed;
-    private previous;
-    private observing;
-    private observeOptions;
-    private pendingTimer;
-    private commitPending;
-    private skipNextResets;
+type QueryFormSignals<TFields extends QueryFormFields> = {
     /**
      * The bindable signal-forms field tree - bind a field with `[formField]`, e.g.
      * `<input etInput [formField]="qf.fields.search" />`.
@@ -7218,8 +7445,9 @@ declare class QueryFormSignals<TFields extends QueryFormFields> {
     readonly activeFilterCount: Signal<number>;
     /** The default value of the whole form. */
     readonly defaultValue: QueryFormModel<TFields>;
-    constructor(config: CreateQueryFormConfig<TFields>);
-    observe(options?: QueryFormSignalsObserveOptions): this;
+    /** Start syncing with the URL. Returns the form, so it can be chained onto the definition. */
+    observe(options?: QueryFormSignalsObserveOptions): QueryFormSignals<TFields>;
+    /** Stop syncing and strip the form's params from the URL. Runs on destroy anyway. */
     unobserve(): void;
     setValue(value: QueryFormModel<TFields>, options?: QueryFormSignalsWriteOptions): void;
     patchValue(value: Partial<QueryFormModel<TFields>>, options?: QueryFormSignalsWriteOptions): void;
@@ -7230,31 +7458,22 @@ declare class QueryFormSignals<TFields extends QueryFormFields> {
     }): void;
     /** Create a detached editor over the same fields, seeded from the current committed value. */
     branch(): QueryFormBranch<TFields>;
-    /**
-     * The live view `<et-query-devtools>` renders. Only built while the devtools are installed - it walks
-     * every field on every change, which an app without them should not pay for.
-     */
-    private devtoolsHandle;
-    private onLiveChange;
-    /** Shortest-debounce-wins; `null` means commit immediately. */
-    private resolveDebounce;
-    private flush;
-    private applyResets;
-    private applyFromUrl;
-    private commitFromUrl;
-    private deserialize;
-    /** What a field puts in the URL for a given value, or `undefined` when it writes nothing. */
-    private queryParamFor;
-    private writeToUrl;
-    private paramKey;
-    private clearTimer;
-    private cleanup;
-}
+};
 /**
- * Create a {@link QueryFormSignals}. Call `.observe()` to start syncing with the
+ * Define a {@link QueryFormSignals}. Call `.observe()` to start syncing with the
  * URL. Must be called in an injection context.
+ *
+ * @example
+ * const qf = defineQueryForm({
+ *   fields: {
+ *     search: searchQueryField(),
+ *     sort: sortQueryField(),
+ *     page: queryField<number>({ defaultValue: 1, isResetBy: ['search', 'sort'] }),
+ *   },
+ * }).observe();
+ * // template: <input etInput [formField]="qf.fields.search" />
  */
-declare const createQueryForm: <TFields extends QueryFormFields>(config: CreateQueryFormConfig<TFields>) => QueryFormSignals<TFields>;
+declare const defineQueryForm: <TFields extends QueryFormFields>(config: DefineQueryFormConfig<TFields>) => QueryFormSignals<TFields>;
 
 /**
  * A generic query-form field. Defaults to `null` and, unless a transform is
@@ -7365,7 +7584,10 @@ type SocketMessageView<TMessageData = unknown> = {
     data: TMessageData;
 };
 type WebSocketClientSubtle = {
-    /** Leave a socket io room */
+    /**
+     * Releases one join of a socket io room. Joiners of the same room share it, so the room is only
+     * actually left once every one of them has released it.
+     */
     leaveRoom: (room: string) => void;
 };
 type WebSocketClient<TMessageData extends SocketMessageView> = {
@@ -7383,6 +7605,11 @@ type WebSocketClient<TMessageData extends SocketMessageView> = {
 };
 type InternalWebSocketRoom<TMessageData extends SocketMessageView> = {
     latestMessage: WritableSignal<TMessageData | null>;
+    /**
+     * How many callers currently hold this room. Joiners share one room object, so the room may only be
+     * left once this reaches zero - otherwise the first caller to unmount stops the messages for the rest.
+     */
+    joinCount: number;
 };
 type WebSocketRoom<TMessageData extends SocketMessageView> = {
     /** The latest message received in the room */
@@ -7392,5 +7619,5 @@ type WebSocketClientResult<TMessageData extends SocketMessageView = SocketMessag
 type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientResult<TMessageData>;
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, 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_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, collectLeafPaths, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryForm, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryFormConfig, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, 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, 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, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAuthQuery, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsOverrideEntry, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunStatus, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, 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, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, 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_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_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, applyQueryDevtoolsOverrides, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, clearQueryDevtoolsTombstones, collectLeafPaths, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsResponseHistory, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, 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, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAuthQuery, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, 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, 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, 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, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };