@ethlete/query 6.0.0-next.54 → 6.0.0-next.55

package/types/ethlete-query.d.ts

@@ -166,12 +166,13 @@ type DefaultRetryOptions = {
      */
     jitter?: number;
     /**
-     * Which response statuses are worth retrying, replacing the defaults rather than adding to them.
-     * A connection failure is status `0`.
+     * Which response statuses are worth retrying. A list replaces the defaults; a function gets the
+     * status and whether the defaults retry it, so `(status, byDefault) => byDefault || status === 500`
+     * adds one. A connection failure is status `0`.
      *
      * @default a connection failure (`0`), `408`, `425`, `429`, and every 5xx above `500`
      */
-    retryableStatusCodes?: number[];
+    retryableStatusCodes?: number[] | ((status: number, isRetryableByDefault: boolean) => boolean);
     /**
      * Also retries a request that is not idempotent (see {@link ShouldRetryRequestOptions.idempotent}). A
      * `POST` whose response was lost may already have been applied, so retrying it can create a
@@ -223,6 +224,7 @@ declare const isQueryErrorResponse: (error: unknown) => error is QueryErrorRespo
 /**
  * Every message carried by an error, flattened into a plain list - one entry for a single error,
  * one per violation for a list (a form response with several field violations), empty for `null`.
+ * Blank messages are dropped; an error left with none yields the raw response's message instead.
  *
  * The single/list split exists because that is how APIs answer; UI almost never wants to branch on
  * it. Reach for this when rendering, and keep {@link QueryErrorResponse} for anything that needs
@@ -664,6 +666,11 @@ type QueryStateSubtle<TArgs extends QueryArgs> = {
      * execution. Set by a feature during creation (`withLongPolling` holds its first round back while disabled).
      */
     autoExecuteGuard: WritableSignal<(() => boolean) | null>;
+    /**
+     * Called by every execution before its request is made; a function it returns is called with that request.
+     * Set by a feature during creation (`withOptimisticUpdate` writes the cache before the request leaves).
+     */
+    beforeExecute: WritableSignal<QueryBeforeExecuteFn<TArgs> | 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
@@ -673,11 +680,19 @@ type QueryStateSubtle<TArgs extends QueryArgs> = {
     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>;
+    /**
+     * Writes the args of an `execute({ args })` over the args source. They stay until the source produces new
+     * non-null args; a source that turns `null` keeps them.
+     */
+    setExplicitArgs: (args: RequestArgs<TArgs>) => void;
+    /** Whether `args` are the ones {@link setExplicitArgs} wrote last and the source has not replaced yet. */
+    isExplicitArgs: (args: RequestArgs<TArgs> | null) => boolean;
     /** @see SetupQueryStateOptions.devtoolsStats */
     devtoolsStats: QueryDevtoolsStatsRecorder | null;
     /** @see SetupQueryStateOptions.devtoolsFormLinks */
     devtoolsFormLinks: QueryDevtoolsFormLinksRecorder | null;
 };
+type QueryBeforeExecuteFn<TArgs extends QueryArgs> = (args: RequestArgs<TArgs> | null) => ((request: HttpRequest<TArgs>) => void) | null;
 type QueryState<TArgs extends QueryArgs> = {
     rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
     response: WritableSignal<ResponseType<TArgs> | null>;
@@ -758,10 +773,15 @@ type QueryExecuteOptions<TArgs extends QueryArgs> = {
     isRefreshable?: boolean;
 };
 declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+/**
+ * A query over a `withArgs` source that returns `null` is parked. Running it would send `null` args, so the
+ * call is dropped with a dev-mode warning.
+ */
+declare const skipParkedExecution: <TArgs extends QueryArgs>(state: QueryState<TArgs>, args: RequestArgs<TArgs> | null | undefined, route: unknown) => boolean;
 /**
  * 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.
+ * A `withLongPolling` round must not look like a new args value, so it is not written. Over a `withArgs`
+ * source only the caller's own non-null args are written, never what a feature re-sends.
  */
 declare const recordExecutionArgs: <TArgs extends QueryArgs>(state: QueryState<TArgs>, args: RequestArgs<TArgs> | null, options?: RunQueryExecuteOptions) => void;
 /**
@@ -786,6 +806,8 @@ type QueryRefreshCause = {
     type: 'refresh' | 'invalidation' | 'mutation';
     /** The URL the refresh was narrowed to (an invalidation's scope, a mutation's URL), or `null`. */
     url: string | null;
+    /** The tag an invalidation was narrowed to, or `null`. */
+    tag?: string | null;
     /** Whether another tab asked for it rather than this one. */
     otherTab: boolean;
 };
@@ -907,6 +929,8 @@ type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
      * as `idempotent`; unset, that falls back to the method not being `POST` or `PATCH`.
      */
     isRefreshable?: boolean;
+    /** @see BaseQueryCreatorOptions.tags */
+    tags?: readonly string[];
 };
 type QueryRepositoryItem<TArgs extends QueryArgs> = {
     /** The key of the request (either a cache key for cacheable requests or a UUID for uncacheable requests) */
@@ -937,6 +961,10 @@ type QueryRepositoryCacheEntry = {
      * consumer that comes back.
      */
     isUnused: boolean;
+    /** @see QueryRepositoryRequestOptions.isRefreshable */
+    isRefreshable: boolean;
+    /** The tags the entry's consumers declared. */
+    tags: readonly string[];
     /** The underlying HTTP request. */
     request: HttpRequest<QueryArgs>;
 };
@@ -957,10 +985,10 @@ type QueryRepositorySubtle = {
     evict: (key: QueryKey) => void;
 };
 /**
- * Narrows which in-use entries a {@link QueryRepository.refreshInUse} call refreshes. Returning
- * `false` leaves the entry alone.
+ * Narrows which in-use entries a {@link QueryRepository.refreshInUse} call refreshes, given the entry's
+ * request and the tags its consumers declared. Returning `false` leaves the entry alone.
  */
-type QueryRepositoryRefreshFilterFn = (request: HttpRequest<QueryArgs>) => boolean;
+type QueryRepositoryRefreshFilterFn = (request: HttpRequest<QueryArgs>, tags?: readonly string[]) => boolean;
 /** @see QueryRepository.applyExternalResponse */
 type ApplyExternalResponseOptions = {
     /** The cache key the response belongs to. */
@@ -999,15 +1027,19 @@ type QueryRepository = {
     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.
+     * in-flight requests. Entries kept only for their `keepUnusedFor` window are not re-executed - nobody is
+     * looking at them, and they revalidate on their own when a consumer binds again. An `invalidation`
+     * marks them stale, so an `allowCache` execution does not serve them either.
      *
      * 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.
      *
+     * An `invalidation` or `mutation` does not restart a request that one of the same batch already
+     * restarted: `batch` names it, and leaving it out makes the current synchronous turn the batch.
+     *
      * @see QueryClient.refreshQueriesInUse
      */
-    refreshInUse: (filter?: QueryRepositoryRefreshFilterFn, cause?: QueryRefreshCause) => void;
+    refreshInUse: (filter?: QueryRepositoryRefreshFilterFn, cause?: QueryRefreshCause, batch?: string) => 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.
@@ -1123,6 +1155,7 @@ declare const QueryFeatureType: {
     readonly WITH_AUTO_REFRESH: "WITH_AUTO_REFRESH";
     readonly WITH_RESPONSE_UPDATE: "WITH_RESPONSE_UPDATE";
     readonly WITH_PAGE_RESET_ON_ERROR: "WITH_PAGE_RESET_ON_ERROR";
+    readonly WITH_OPTIMISTIC_UPDATE: "WITH_OPTIMISTIC_UPDATE";
 };
 type QueryFeatureType = (typeof QueryFeatureType)[keyof typeof QueryFeatureType];
 type QueryFeatureContext<TArgs extends QueryArgs> = {
@@ -1153,7 +1186,8 @@ declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
  *
  * 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. A mutation that is still in flight
- * finishes first and the query parks once it has settled.
+ * finishes first and the query parks once it has settled. `execute({ args })` runs and keeps other args
+ * until this function produces new non-null ones.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
@@ -1312,7 +1346,7 @@ type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
     /**
      * A function that will be called with the latest response
      * If the function returns `null`, the response will not be updated.
-     * Otherwise, the response will be updated with the returned value.
+     * Otherwise, the returned value becomes `response()` as is: it is not passed through `transformResponse` again.
      * The function will be called in a reactive signal context.
      * If the query get's executed after the response was updated, the response will be set the the fresh data received from the server.
      *
@@ -1322,17 +1356,16 @@ type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
      * const matchEvents = mySocket.joinRoom('match-events');
      *
      * const myMatchQuery = getMatch(
-     *  withArgs(() => ({ matchId: 1 })),
-     *  withResponseUpdate(({ currentResponse }) => {
-     *   const matchEvent = matchEvents();
-     *
-     *   if (!matchEvent) return null;
+     *  withArgs(() => ({ pathParams: { matchId: 1 } })),
+     *  withResponseUpdate({
+     *   updater: ({ currentResponse }) => {
+     *    const matchEvent = matchEvents();
      *
-     *   // Do some checks here. This is just a very simple example.
-     *   // To apply partial updates, you can use the spread operator in combination with the current response.
+     *    if (!matchEvent || !currentResponse) return null;
      *
-     *   return matchEvent;
-     *  })
+     *    return { ...currentResponse, score: matchEvent.score };
+     *   },
+     *  }),
      * )
      */
     updater: (data: WithResponseUpdateFeatureFnData<TArgs>) => ResponseType<TArgs> | null;
@@ -1494,6 +1527,28 @@ type BaseQueryCreatorOptions<TArgs extends QueryArgs = QueryArgs> = {
      * @default true for public queries, false for secure ones
      */
     persistence?: boolean;
+    /**
+     * Tags of a read, for {@link QueryClient.invalidateQueries} `{ tag }` and the `invalidates` option of a
+     * mutation. Derived from the args, so a read is tagged before its request leaves and an invalidation
+     * restarts it even while it is in flight. Has no effect on mutations.
+     *
+     * @example
+     * createGetQuery(client)<GetOpportunityArgs>((p) => `/opportunities/${p.uuid}`, {
+     *   tags: ({ args }) => [`opportunity:${args.pathParams.uuid}`],
+     * });
+     */
+    tags?: QueryTagsOption<TArgs>;
+    /**
+     * What a successful mutation invalidates: each target runs {@link QueryClient.invalidateQueries} once the
+     * response landed, here and in the user's other tabs. A failed mutation invalidates nothing. Throws on a
+     * read, which would invalidate on every load.
+     *
+     * @example
+     * createPatchQuery(client)<PatchPersonArgs>((p) => `/opportunities/${p.uuid}/people/${p.peopleUuid}`, {
+     *   invalidates: ({ args }) => [{ tag: `opportunity:${args.pathParams.uuid}` }, { url: '/people' }],
+     * });
+     */
+    invalidates?: QueryInvalidatesOption<TArgs>;
     /** Advanced query creator features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
     subtle?: BaseQueryCreatorOptionsSubtle;
 };
@@ -1591,15 +1646,6 @@ type QueryConfig = {
      * If true, the query will not throw an error because a "withArgs()" feature is missing.
      */
     silenceMissingWithArgsFeatureError?: boolean;
-    /**
-     * If true, executing with `allowCache` on a request that cannot be cached is ignored instead of throwing
-     * `ET301`.
-     *
-     * For the legacy interop layer: v2 had a single `skipCache` for every method, so it forwards `allowCache`
-     * without being able to tell a cacheable request from an uncacheable one. Application code should not set
-     * 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,
@@ -1629,6 +1675,8 @@ type QueryInvalidationCandidate = {
  * @see QueryInvalidationOptions.filter
  */
 type QueryInvalidationFilterFn = (query: QueryInvalidationCandidate) => boolean;
+/** A root-relative route (`/players`), resolved against the client's `baseUrl`, or an absolute URL. */
+type QueryInvalidationUrl = `/${string}` | `${string}://${string}`;
 /** @see QueryClient.invalidateQueries */
 type QueryInvalidationOptions = {
     /**
@@ -1638,7 +1686,12 @@ type QueryInvalidationOptions = {
      * Matching is boundary aware rather than a plain prefix test, so `/players` covers `/players`,
      * `/players/1` and `/players?page=2` - but not `/players-archive`.
      */
-    url?: string;
+    url?: QueryInvalidationUrl;
+    /**
+     * Narrows the invalidation to the reads that declared this tag (see {@link BaseQueryCreatorOptions.tags}).
+     * Combined with `url`, a read has to match both.
+     */
+    tag?: string;
     /**
      * Narrows the invalidation further, on the built `{ method, url }` of each candidate. Runs after
      * `url` when both are given.
@@ -1675,8 +1728,34 @@ declare const isUnderInvalidatedUrl: (queryUrl: string, invalidatedUrl: string)
  */
 declare const createQueryInvalidationFilter: (options: {
     url: string | null;
+    tag?: string | null;
     filter?: QueryInvalidationFilterFn;
 }) => QueryRepositoryRefreshFilterFn | undefined;
+/** One thing a mutation invalidates: everything below a URL, or every read that declared a tag. */
+type QueryInvalidationTarget = {
+    url: QueryInvalidationUrl;
+} | {
+    tag: string;
+};
+/** What a {@link BaseQueryCreatorOptions.invalidates} function is handed after a successful mutation. */
+type QueryInvalidatesContext<TArgs extends QueryArgs> = {
+    /** The args the mutation was sent with. */
+    args: RequestArgs<TArgs>;
+    /** The mutation's response, or `null` for an empty one (a `204`). */
+    response: ResponseType<TArgs> | null;
+};
+type Bivariant<TContext, TResult> = {
+    fn(context: TContext): TResult;
+}['fn'];
+/** @see BaseQueryCreatorOptions.invalidates */
+type QueryInvalidatesOption<TArgs extends QueryArgs> = readonly QueryInvalidationTarget[] | Bivariant<QueryInvalidatesContext<TArgs>, readonly QueryInvalidationTarget[]>;
+/** What a {@link BaseQueryCreatorOptions.tags} function is handed when the read executes. */
+type QueryTagsContext<TArgs extends QueryArgs> = {
+    /** The args the read is sent with. */
+    args: RequestArgs<TArgs>;
+};
+/** @see BaseQueryCreatorOptions.tags */
+type QueryTagsOption<TArgs extends QueryArgs> = readonly string[] | Bivariant<QueryTagsContext<TArgs>, readonly string[]>;
 
 /**
  * Schema version of the persisted store, owned by this library. Bumping it makes the storage adapter
@@ -2078,6 +2157,8 @@ type QuerySyncMutationMessage = {
     method: QueryMethod;
     /** The full URL the mutation was sent to. */
     url: string;
+    /** @see QuerySyncInvalidateMessage.batch */
+    batch?: string;
 };
 /** Another tab was told to invalidate queries, explicitly. */
 type QuerySyncInvalidateMessage = {
@@ -2087,6 +2168,16 @@ type QuerySyncInvalidateMessage = {
      * resolved by the tab that sent it - the two tabs run the same client, so its `baseUrl` is ours.
      */
     url: string | null;
+    /**
+     * The tag the invalidation was narrowed to, or `null`. A tab from an older deploy ignores the field and
+     * invalidates by `url` alone, a superset.
+     */
+    tag?: string | null;
+    /**
+     * Shared by the messages one tab posted in the same synchronous turn, so the receiver restarts a read
+     * once for all of them. A tab from an older deploy neither sends nor reads it, and restarts once per message.
+     */
+    batch?: string;
 };
 type QuerySyncMessage = QuerySyncResponseMessage | QuerySyncMutationMessage | QuerySyncInvalidateMessage;
 /** What actually travels over the channel: a message plus the protocol version that produced it. */
@@ -2138,10 +2229,10 @@ type QuerySyncEngine = {
     /** Elects the one tab responsible for a cache key. */
     lockManager: QueryKeyLockManager;
     /**
-     * Tells the other tabs to refresh the queries they have in use below `url`, or all of them for
-     * `null`. What {@link QueryClient.invalidateQueries} broadcasts.
+     * Tells the other tabs to refresh the queries they have in use below `url` and tagged `tag`, or all
+     * of them for two `null`s. What {@link QueryClient.invalidateQueries} broadcasts.
      */
-    postInvalidation: (url: string | null) => void;
+    postInvalidation: (url: string | null, tag?: string | null) => void;
     /** Stops broadcasting and listening, and closes the channel. */
     destroy: () => void;
 };
@@ -2465,18 +2556,20 @@ type QueryClient = {
      * date - after a mutation, or a push message saying something changed server-side - and tells the
      * user's other tabs to do the same.
      *
-     * Narrow it by `url`, by `filter`, or leave it open to invalidate everything in use:
+     * Narrow it by `url`, `tag`, `filter`, or leave it open to invalidate everything in use. A mutation
+     * creator's `invalidates` option calls this for you after a successful response.
      *
      * @example
-     * await createPlayer.execute({ body });
+     * await executeUntilSettled(createPlayer, { args: { body } });
      *
      * client.invalidateQueries({ url: '/players' }); // /players, /players/1, /players?page=2
+     * client.invalidateQueries({ tag: 'player:1' }); // every read whose `tags` include it
      * client.invalidateQueries(); // everything on screen, here and in the other tabs
      *
      * 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.
+     * window are only marked stale - refreshing what nobody is looking at is how an invalidation turns
+     * into a request storm - so the next consumer, or an `allowCache` execution, refetches them.
      *
      * Reaching the other tabs needs the {@link withMultiTabSync} client feature; without it this is a
      * local call, and `otherTabs: false` makes it one deliberately.
@@ -2691,6 +2784,13 @@ type HttpRequestSubtle<TArgs extends QueryArgs> = {
      * instead of retrying into an empty room.
      */
     abort: () => boolean;
+    /** Ends the freshness window of the response it holds, so the next `allowCache` execution sends the request. */
+    markStale: () => void;
+    /**
+     * Replaces the response every query bound to this request shows, without an event and without touching
+     * its freshness. What `withOptimisticUpdate` writes and rolls back.
+     */
+    setResponse: (body: ResponseType<TArgs> | null) => void;
 };
 type HttpRequest<TArgs extends QueryArgs> = {
     /** The HTTP method of the request. */
@@ -2789,7 +2889,7 @@ type QueryArgs = {
     headers?: QueryHeadersInput;
 };
 type ResponseType<T extends QueryArgs | null> = T extends QueryArgs ? T['response'] : never;
-type RawResponseType<T extends QueryArgs | null> = T extends QueryArgs ? T['rawResponse'] extends undefined ? T['response'] : T['rawResponse'] : never;
+type RawResponseType<T extends QueryArgs | null> = T extends QueryArgs ? 'rawResponse' extends keyof T ? T['rawResponse'] extends undefined ? T['response'] : T['rawResponse'] : T['response'] : never;
 type PathParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['pathParams'] : never;
 type QueryParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['queryParams'] : never;
 type BodyType<T extends QueryArgs | null> = T extends QueryArgs ? T['body'] : never;
@@ -2870,6 +2970,11 @@ type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     execute: QueryExecute<TArgs>;
     /** Creates an immutable snapshot of the current query state */
     createSnapshot: () => QuerySnapshot<TArgs>;
+    /**
+     * The full URL (base, path params and query params) of the request the query is bound to. `null`
+     * before the first execution.
+     */
+    url: ObservableSignal<string | null>;
     /** Resets the query state to its initial state */
     reset: () => void;
     /**
@@ -3545,6 +3650,11 @@ 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 INVALIDATES_USED_ON_READ: 2;
+    readonly QUERY_CREATED_OUTSIDE_INJECTION_CONTEXT: 3;
+    readonly INVALID_BASE_URL: 10;
+    readonly INVALID_ROUTE: 11;
+    readonly PATH_PARAMS_MISSING_IN_ROUTE_FUNCTION: 12;
     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;
@@ -3552,10 +3662,12 @@ declare const QueryRuntimeErrorCode: {
     readonly SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT: 104;
     readonly WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 105;
     readonly WITH_LONG_POLLING_USED_WITH_POLLING: 106;
+    readonly WITH_OPTIMISTIC_UPDATE_USED_ON_READ: 107;
     readonly AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT: 200;
     readonly AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN: 201;
     readonly AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_REFRESH_TOKEN: 202;
     readonly AUTH_PROVIDER_FEATURE_USED_MULTIPLE_TIMES: 203;
+    readonly AUTH_ACCESS_TOKEN_EXPIRY_UNREADABLE: 204;
     readonly QUERY_CLIENT_FEATURE_USED_MULTIPLE_TIMES: 250;
     readonly UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM: 300;
     readonly UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM: 301;
@@ -3581,6 +3693,8 @@ declare const QueryRuntimeErrorCode: {
 type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
 declare const queryFeatureUsedMultipleTimes: (type: string) => RuntimeError<0>;
 declare const queryCreatedInReactiveContext: () => RuntimeError<1>;
+declare const invalidatesUsedOnRead: (method: string) => RuntimeError<2>;
+declare const withOptimisticUpdateUsedOnRead: (method: string) => RuntimeError<107>;
 declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<100>;
 declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<101>;
 declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<102>;
@@ -3592,6 +3706,7 @@ declare const authExtractTokensResponseNotObject: () => RuntimeError<200>;
 declare const authExtractTokensResponseMissingAccessToken: () => RuntimeError<201>;
 declare const authExtractTokensResponseMissingRefreshToken: () => RuntimeError<202>;
 declare const authProviderFeatureUsedMultipleTimes: (type: string) => RuntimeError<203>;
+declare const authAccessTokenExpiryUnreadable: (claim: string) => RuntimeError<204>;
 declare const queryClientFeatureUsedMultipleTimes: (type: string) => RuntimeError<250>;
 declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<300>;
 declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<301>;
@@ -3606,17 +3721,127 @@ declare const tokensNotAvailableInsideAuthAndExec: () => RuntimeError<700>;
 declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
 declare const circularQueryDependency: () => RuntimeError<800>;
 declare const queryExecutedAfterDestroyMessage: (route: unknown) => string;
+declare const queryExecutedWhileParkedMessage: (route: unknown) => string;
 declare const legacyPrepareWithoutInjectionContext: (creatorName: string | undefined, method?: "prepare" | "createSubject" | "createSignal") => RuntimeError<950>;
 declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
 declare const queryBatchAlreadyRunning: () => RuntimeError<910>;
 declare const queryBatchWithArgsUsed: () => RuntimeError<911>;
 
+/** The fixed members of a query group, keyed by the name the group reports them under. */
+type QueryGroupMembers = Record<string, AnyNewQuery>;
+type QueryGroupMemberResponse<TQuery> = TQuery extends Query<infer TArgs> ? ResponseType<TArgs> : never;
+type QueryGroupKey<TMembers extends QueryGroupMembers> = keyof TMembers & string;
+/** The member that ran last and its current response, which is `null` until it has one. */
+type QueryGroupLatest<TMembers extends QueryGroupMembers> = {
+    [TKey in QueryGroupKey<TMembers>]: {
+        key: TKey;
+        response: QueryGroupMemberResponse<TMembers[TKey]> | null;
+    };
+}[QueryGroupKey<TMembers>];
+/** A settled, successful execution of one member. */
+type QueryGroupSuccess<TMembers extends QueryGroupMembers> = {
+    [TKey in QueryGroupKey<TMembers>]: {
+        key: TKey;
+        response: QueryGroupMemberResponse<TMembers[TKey]>;
+    };
+}[QueryGroupKey<TMembers>];
+/**
+ * A fixed set of queries of which the one executed last wins - an action set like accept/decline or
+ * create/edit/delete. Built by {@link createQueryGroup}.
+ */
+type QueryGroup<TMembers extends QueryGroupMembers> = {
+    /** The members. Executing one through here records it as {@link QueryGroup.latest}; executing the query you passed in does not. */
+    members: TMembers;
+    /** The loading state of a member that is loading, the latest one first. `null` when none is. */
+    loading: Signal<HttpRequestLoadingState | null>;
+    /** The error of the latest member only, so an older member's failure clears once another one runs. */
+    error: Signal<QueryErrorResponse | null>;
+    /** The member executed last, or `null` before the first execution. */
+    latest: Signal<QueryGroupLatest<TMembers> | null>;
+    /** Re-runs the latest member with its last args. Does nothing before the first execution. */
+    execute: (executeArgs?: {
+        options?: RunQueryExecuteOptions;
+    }) => void;
+    /** Emits once for every member execution through the group that succeeds. Completes when the group's injection context is destroyed. */
+    succeeded$: Observable<QueryGroupSuccess<TMembers>>;
+};
+type AnyQueryGroup = QueryGroup<QueryGroupMembers>;
+/**
+ * Groups a fixed set of queries of which the one executed last wins. The group fits `etQueryButton` and
+ * `et-query-error`'s `[query]`, which retries the member that ran last. Call it in an injection context.
+ *
+ * @example
+ * readonly actions = createQueryGroup({
+ *   accept: postAcceptInvitation(withArgs(() => ({ pathParams: { id: this.id() } }))),
+ *   decline: postDeclineInvitation(withArgs(() => ({ pathParams: { id: this.id() } }))),
+ * });
+ *
+ * accept() {
+ *   this.actions.members.accept.execute();
+ * }
+ */
+declare const createQueryGroup: <TMembers extends QueryGroupMembers>(members: TMembers) => QueryGroup<TMembers>;
+
 /**
  * `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>;
 
+/** What {@link WithOptimisticUpdateOptions.update} is handed. */
+type OptimisticUpdateContext<TArgs extends QueryArgs, TCurrent> = {
+    /** The cached response of the read being updated, as the server sent it (before its `transformResponse`). */
+    current: TCurrent;
+    /** The args the mutation is sent with. */
+    args: RequestArgs<TArgs>;
+    /**
+     * `undefined` before the request. After a successful one, the mutation's response, or `null` for an empty
+     * one (a `204`).
+     */
+    response?: ResponseType<TArgs> | null;
+};
+type OptimisticCurrent<TRead extends QueryArgs> = [TRead] extends [never] ? unknown : RawResponseType<TRead>;
+/** @see withOptimisticUpdate */
+type WithOptimisticUpdateOptions<TArgs extends QueryArgs, TRead extends QueryArgs = never> = {
+    /**
+     * The read creator whose entries `target` matches. Only types `current`; the entries are found by `target`
+     * alone, so it must not match entries of another read. Without it, `current` is `unknown`.
+     */
+    read?: QueryCreator<TRead>;
+    /** The cache entries to update: every read below a URL, or every read that declared a tag. */
+    target: (context: {
+        args: RequestArgs<TArgs>;
+    }) => QueryInvalidationTarget | readonly QueryInvalidationTarget[];
+    /**
+     * Returns the next response of one matched entry, or `null` to leave it alone. Called before the request,
+     * again with `response` after a successful one (`null` there keeps the earlier result), and again whenever
+     * another optimistic update of the same entry rolls back. Must be pure.
+     */
+    update: (context: OptimisticUpdateContext<TArgs, OptimisticCurrent<TRead>>) => OptimisticCurrent<TRead> | null;
+};
+/**
+ * Writes the expected result of a mutation into the cached responses of the reads `target` matches before
+ * the request leaves, and rolls those writes back if it fails or is cancelled. Pair it with the creator's
+ * `invalidates`, whose refetch corrects a wrong guess. The writes stay in this tab; the invalidation reaches
+ * the others.
+ *
+ * A rollback leaves an entry alone that a refetch or another tab wrote in the meantime; other optimistic
+ * updates of the entry still pending are re-applied on top of what it held before.
+ *
+ * @example
+ * patchOpportunityPerson(
+ *   withArgs(() => ({ pathParams: { uuid, peopleUuid }, body })),
+ *   withOptimisticUpdate({
+ *     read: getOpportunity,
+ *     target: ({ args }) => ({ tag: `opportunity:${args.pathParams.uuid}` }),
+ *     update: ({ current, args }) => ({ ...current, people: toggle(current.people, args.pathParams.peopleUuid) }),
+ *   }),
+ * );
+ *
+ * @throws If the query is a read (e.g. a GET request)
+ */
+declare const withOptimisticUpdate: <TArgs extends QueryArgs, TRead extends QueryArgs = never>(options: WithOptimisticUpdateOptions<TArgs, TRead>) => QueryFeature<TArgs>;
+
 /** 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. */
@@ -4062,6 +4287,7 @@ type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
     authProvider: AnyBearerAuthProvider;
     deps: QueryDependencies;
     state: QueryState<TArgs>;
+    route?: unknown;
     /**
      * 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;
@@ -4220,6 +4446,9 @@ type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> &
         /**
          * HTTP status codes that should trigger a retry.
          * Code 0 means network error (no internet).
+         *
+         * Unlike `createDefaultRetryFn`, the default retries a `500`: a refresh that fails for good ends the
+         * session, so waiting out a backend error is cheaper than logging the user out.
          * @default [0, 408, 425, 429, 500, 502, 503, 504]
          */
         retryableStatusCodes?: number[];
@@ -4555,7 +4784,9 @@ type TokenExpirationWarningConfig = {
 };
 type TokenExpirationWarningFeature = {
     /**
-     * Signal that emits true when token is about to expire
+     * `true` while the access token is inside `warningThreshold` of its expiry and nothing is going to
+     * renew it: there is no refresh query or refresh token, or the scheduled refresh is overdue by 10 s
+     * (or half the refresh buffer, if that is shorter) - it failed, was throttled, or is still in flight. A routine refresh never turns it on.
      */
     isExpiringSoon: Signal<boolean>;
     /**
@@ -4747,7 +4978,8 @@ type BearerAuthExecutionState<TType extends string = string> = BearerAuthExecuti
 /**
  * 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.
+ * - `unknown` - the provider has not finished its own startup yet. With multi-tab sync and a cookie to
+ *   restore from, a joining tab stays here for up to 250 ms after `inject` returns, while it asks the leader.
  * - `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.
@@ -4945,7 +5177,9 @@ type CreateBearerAuthProviderConfig<TBuilders extends readonly AnyQueryBuilder[]
      */
     features?: TFeatures;
     /**
-     * A function that decrypts the bearer token
+     * Turns the access token into what `bearerData()` holds. Returning `null` means the token carries no
+     * usable data. The proactive refresh reads the expiry claim off the result, and off the raw JWT
+     * payload when the result has none.
      * @default decryptBearer()
      */
     bearerDecryptFn?: (token: string) => TBearerData;
@@ -4985,14 +5219,17 @@ type BearerAuthProvider<TBuilders extends readonly AnyQueryBuilder[], TFeatures
      */
     isAccessTokenExpired: () => boolean;
     /**
-     * The latest executed query (including internal triggers like auto-refresh)
+     * The key and snapshot of the latest auth query run, including the provider's own runs (auto-login,
+     * token refresh). A token revocation does not count. `null` before the first run and after a logout.
+     * To follow one query, prefer `queries.<key>.snapshot()`; for progress, `executionState()`.
      */
     latestExecutedQuery: Signal<{
         key: ExtractQueryKey<TBuilders[number]>;
         snapshot: QuerySnapshot<QueryArgs>;
     } | null>;
     /**
-     * The latest non-internal query (user-triggered only)
+     * Like {@link latestExecutedQuery}, but only for runs the app started: an `execute()` without a
+     * `triggeredBy`. `null` before the first such run and after a logout.
      */
     latestNonInternalQuery: Signal<{
         key: ExtractQueryKey<TBuilders[number]>;
@@ -5113,6 +5350,8 @@ type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends rea
      * all, so the provider cannot work it out on its own.
      */
     reportAccessTokenExpiry: (isExpired: () => boolean) => void;
+    /** Hands the provider the claim that carries the access token's expiry. `exp` until reported. */
+    reportExpiresInPropertyName: (claim: string) => void;
 };
 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>>;
@@ -5547,349 +5786,129 @@ declare const setQueryDevtoolsAuthTabLocal: (options: {
 }) => void;
 
 /**
- * Where one kind of devtools state is kept between page loads. `none` means it is not kept at all -
- * what that costs differs per kind, which is why every kind picks its own.
+ * The kind of object a {@link QueryDevtoolsEntry} describes. Part of the devtools contract consumed
+ * by `<et-query-devtools>` - not a general-purpose query API.
  */
-type QueryDevtoolsStorageScope = 'none' | 'session' | 'local';
+type QueryDevtoolsEntryKind = 'query' | 'query-stack' | 'paged-query-stack' | 'query-sequence' | 'query-batch' | 'auth-provider' | 'ws-client' | 'query-form';
 /**
- * The devtools' own configuration: where each kind of panel state is kept, and the limits the panel
- * would otherwise hold as constants. Read it as {@link queryDevtoolsSettings}, change it with
- * {@link setQueryDevtoolsSettings}.
+ * One chunk of a parsed query route: either literal text (`param: null`) or a path param, whose name
+ * is in {@link QueryDevtoolsRoutePart.text}. Lets the devtools tell a route's static parts from its
+ * dynamic ones and fill the latter in with the values a query actually used.
  */
-type QueryDevtoolsSettings = {
-    /** Panel chrome and view state: dock, sizes, open tab, filters, selections. */
-    viewState: QueryDevtoolsStorageScope;
-    /** The entry ids sorted to the top of the Queries list. */
-    pins: QueryDevtoolsStorageScope;
+type QueryDevtoolsRoutePart = {
+    text: string;
+    param: string | null;
+};
+/**
+ * One of a bearer auth provider's queries, described without instantiating it - which is what lets
+ * tooling build the token-refresh request of a provider whose refresh query has not run yet.
+ */
+type QueryDevtoolsAuthQuery = {
+    key: string;
+    /** `token-refresh` for the query registered via `withRefreshQuery`, `auth` for the rest. */
+    kind: 'auth' | 'token-refresh';
+    method: string;
+    /** Stringified route with path params rendered as `:name`. */
+    route: string;
+    /** The args a token refresh sends for a given refresh token. Only set on the refresh query. */
+    buildArgs?: (refreshToken: string) => {
+        body?: unknown;
+    };
+};
+/**
+ * Descriptive, mostly-static metadata about a registered devtools entry. The live, reactive state
+ * is read from the entry's {@link QueryDevtoolsEntry.handle} instead.
+ */
+type QueryDevtoolsEntryMeta = {
+    /** Display name of the owning query client, where known. */
+    clientName?: string;
+    /** Base URL of the owning query client, where known. */
+    clientBaseUrl?: string;
+    /** Human readable display name (e.g. an auth provider or web socket client name). */
+    name?: string;
+    /** The connection URL, for web socket clients. */
+    url?: string;
+    /** The GraphQL document string, for GraphQL queries. */
+    gqlQuery?: string;
+    /** Stringified route with path params rendered as `:name`, for queries. */
+    route?: string;
+    /** The same route, split into its literal and path-param parts. */
+    routeParts?: QueryDevtoolsRoutePart[];
+    /** Human readable HTTP/GQL method, for queries (e.g. `GET`, `GQL QUERY`). */
+    method?: string;
+    /** The features applied at creation, with the options each was configured with. */
+    features?: QueryDevtoolsFeature[];
+    /** Whether the query authenticates through a bearer auth provider, for queries. */
+    isSecure?: boolean;
+    /** Name of the bearer auth provider a secure query authenticates with. */
+    authProviderName?: string;
+    /** The provider's own queries, for auth providers. */
+    authQueries?: QueryDevtoolsAuthQuery[];
     /**
-     * Armed response overrides, replayed as queries register on the next load. `none` by default: an app
-     * that stays tampered with across reloads is hours of debugging the wrong thing.
+     * The batch that created a query, for the one query `createQueryBatch` runs per item. The panel folds
+     * such queries under their batch's own entry instead of listing a row per item, and the registry caps
+     * their tombstones per batch so a bulk run cannot evict everything else it kept.
      */
-    overrides: QueryDevtoolsStorageScope;
-    /** The library of designed mocks - the authoring, not whether any of them is armed. */
-    mocks: QueryDevtoolsStorageScope;
+    batch?: QueryBatchDevtoolsHandle;
+    /** Which of the batch's items the query was created for, for a batch's item query. */
+    batchItemIndex?: number;
+    /** How many of a batch's requests may be in flight at once, for batches. */
+    concurrency?: number;
+    /** Whether a batch's first failure stops the rest of the run, for batches. */
+    stopOnError?: boolean;
+    /** The query config passed at creation, for queries. */
+    queryConfig?: QueryConfig;
+    /** The creator options passed at creation, for queries. */
+    creator?: CreateQueryCreatorOptions;
+    /** The owning client's repository, where known (queries and auth providers). */
+    repository?: QueryRepository;
     /**
-     * Which mocks are **armed**, as opposed to the library above. `none` by default: an app that silently
-     * serves designed data tomorrow morning is worse than arming them again, so keeping them is a choice
-     * someone makes rather than the way the panel ships.
+     * The owning client itself, where known (queries and auth providers). Read for state that hangs off
+     * the client rather than the repository - the multi-tab sync engine, in particular.
      */
-    armedMocks: QueryDevtoolsStorageScope;
-    /** The faults armed per client, for the same reason and with the same default. */
-    armedFaults: QueryDevtoolsStorageScope;
+    client?: QueryClient;
     /**
-     * The session vault: the token pairs the panel switches between, and the credentials it logs in with.
-     * `local` by default, because a vault that forgets the other user on every reload is not one - and
-     * `none` for a machine where nothing of the sort may be kept. Outside a development build `local` is
-     * refused and read back as `session`, see {@link queryDevtoolsAllowsLocalAuthSessions}.
+     * The DOM element of the component/directive that created a query, when available. Used by the
+     * devtools "inspect" tool to map a query back to its place in the live UI.
      */
-    authSessions: QueryDevtoolsStorageScope;
-    /** How many entries the Events log keeps. */
-    maxEvents: number;
-    /** How many dropped cache entries the Cache tab remembers, per client. */
-    maxDroppedCacheEntries: number;
+    element?: HTMLElement | null;
+};
+/**
+ * A single entry in the {@link queryDevtoolsEntries} registry. The `handle` is the live object
+ * (query, stack, sequence or auth provider) so its signals stay reactive when read by the UI.
+ */
+type QueryDevtoolsEntry = {
+    id: string;
+    kind: QueryDevtoolsEntryKind;
+    meta: QueryDevtoolsEntryMeta;
+    handle: unknown;
+    createdAt: number;
     /**
-     * How many bodies each query retains, overriding `provideQueryDevtools({ responseHistory })` for the
-     * rest of this page. `null` leaves the application's value alone.
+     * 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.
      */
-    responseHistory: number | null;
+    destroyedAt?: number | null;
     /**
-     * Whether switching to another session reloads the page. On by default: a switch replaces what the
-     * query layer holds, and an application that keeps the user anywhere else - a profile service, the
-     * router, an open form - is still showing the last one until it boots again.
+     * 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.
      */
-    reloadOnAuthSwitch: boolean;
+    stats?: QueryDevtoolsStatsHandle;
+    /** The query forms this entry's args read, for queries created with a `withArgs` feature. */
+    formLinks?: QueryDevtoolsFormLinksHandle;
+    /**
+     * The response overrides armed on this entry, for queries. Unlike {@link stats}/{@link formLinks} -
+     * whose write side is internal instrumentation the panel only ever reads - the panel itself is what
+     * arms an override, so this exposes the full recorder rather than a read-only handle.
+     */
+    overrides?: QueryDevtoolsOverridesRecorder;
 };
 /**
- * How the devtools are configured. Every consumer reads the live value rather than a copy, so a change
- * in the panel's Settings takes effect without a reload.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const queryDevtoolsSettings: Signal<QueryDevtoolsSettings>;
-/**
- * The `Storage` a scope names, or `null` for `none` and for a browser that refuses one (private mode,
- * storage disabled, server-side rendering). Callers treat "no storage" and "not persisted" alike.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const queryDevtoolsStorage: (scope: QueryDevtoolsStorageScope) => Storage | null;
-/**
- * Reads one JSON-encoded devtools key from the store a scope names, or `null`.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const readQueryDevtoolsStore: <T>(scope: QueryDevtoolsStorageScope, key: string) => T | null;
-/**
- * Writes one devtools key into the store a scope names. A scope of `none` writes nothing.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const writeQueryDevtoolsStore: (scope: QueryDevtoolsStorageScope, key: string, value: unknown) => void;
-/**
- * Removes one devtools key from **both** stores, whatever the scope currently is - so a scope that
- * changed cannot leave a stale copy behind for the next load to read.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const clearQueryDevtoolsStore: (key: string) => void;
-/**
- * Whether the session vault may be kept in `localStorage`. Only a development build may: the vault
- * holds live access and refresh tokens plus the credentials somebody typed in, and a deployed
- * application that mounts the panel for its debugging value must not leave those on the machine of
- * whoever opened it. Outside a development build a stored or default `local` reads back as `none`, so a
- * plain login keeps nothing; `session` stays on offer for whoever picks it in Settings.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const queryDevtoolsAllowsLocalAuthSessions: () => boolean;
-/**
- * Changes part of the devtools configuration and stores it. Values outside the range a field allows are
- * clamped rather than rejected.
- *
- * Overrides are the one field not to set here: their scope moves an existing store, so it goes through
- * `setQueryDevtoolsOverridesScope()` instead.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const setQueryDevtoolsSettings: (patch: Partial<QueryDevtoolsSettings>) => void;
-
-/**
- * A fault armed on one query client from the devtools panel. Unlike the panel's forced states - which
- * write a query's signals directly - an armed fault is applied inside the request pipeline, so retries,
- * error handling features and the cache all see it exactly as they would see a real one.
- */
-type QueryDevtoolsFault = {
-    /** Extra latency in ms added before every attempt starts. `0` disables it. */
-    latencyMs: number;
-    /**
-     * How many upcoming attempts fail before the client is let through again, counted down as they are
-     * consumed. `0` disables it.
-     */
-    failNext: number;
-    /** The percentage of attempts that fail, rolled per attempt. `0` disables it, `100` fails everything. */
-    failRate: number;
-    /** The status an injected failure responds with. */
-    status: number;
-};
-/** The neutral fault: nothing armed. */
-declare const EMPTY_QUERY_DEVTOOLS_FAULT: QueryDevtoolsFault;
-/**
- * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
- * this cannot arm a 500 and then leave you wondering why no retry fired.
- * @see runDefaultQueryRetry
- */
-declare const QUERY_DEVTOOLS_FAULT_STATUSES: {
-    status: number;
-    label: string;
-    retryable: boolean;
-}[];
-/**
- * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
- * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
- */
-declare const queryDevtoolsFaults: Signal<Record<string, QueryDevtoolsFault>>;
-/**
- * Whether what is armed right now came back from a previous page load rather than being armed by hand.
- * The panel's armed bar says so, because injected failures nobody remembers arming look exactly like a
- * broken API.
- */
-declare const queryDevtoolsFaultsRestored: Signal<boolean>;
-/**
- * Where the armed faults are kept. Switching to a scope that keeps them stores whatever is armed right
- * now; switching to `none` empties the store and leaves this page's faults exactly where they are.
- */
-declare const setQueryDevtoolsFaultsScope: (next: QueryDevtoolsStorageScope) => void;
-/** Whether anything at all is armed on a fault. */
-declare const isQueryDevtoolsFaultArmed: (fault: QueryDevtoolsFault) => boolean;
-/**
- * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
- * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
- *
- * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
- * something an application should arm on itself.
- */
-declare const setQueryDevtoolsFault: (options: {
-    clientName: string;
-    patch: Partial<QueryDevtoolsFault>;
-}) => void;
-/**
- * Disarms every fault of one client, or of all clients when no name is given.
- *
- * @see setQueryDevtoolsFault
- */
-declare const clearQueryDevtoolsFaults: (clientName?: string) => void;
-
-/**
- * One field of a query form, as the devtools panel reads it: what it holds, what it puts in the URL,
- * and the rules that decide when either changes.
- */
-type QueryDevtoolsFormField = {
-    key: string;
-    /** The query-param key the field serializes to, with the form's prefix applied. */
-    paramKey: string;
-    /** The committed value - what the query args are built from. */
-    value: unknown;
-    /** The live value of the bound control, which differs from {@link value} while a debounce is pending. */
-    liveValue: unknown;
-    defaultValue: unknown;
-    /** Whether the committed value is the default one. */
-    isDefault: boolean;
-    /** What the field writes to the URL, or `undefined` when it writes nothing. */
-    queryParam: unknown;
-    /** How long a change waits before it is committed, or `null` when it commits immediately. */
-    debounceMs: number | null;
-    /** The sibling fields whose change resets this one back to its default. */
-    isResetBy: readonly string[];
-    /** Whether the field counts towards {@link QueryDevtoolsFormHandle.activeFilterCount}. */
-    countsAsFilter: boolean;
-};
-/**
- * The live state of a query form, as `<et-query-devtools>` renders it. Part of the devtools contract -
- * not a general-purpose query-form API.
- */
-type QueryDevtoolsFormHandle = {
-    fields: Signal<QueryDevtoolsFormField[]>;
-    /** The committed value of the whole form. */
-    value: Signal<Record<string, unknown>>;
-    /** The value of every field before the most recent commit, or `null` before the first one. */
-    previousValue: Signal<Record<string, unknown> | null>;
-    defaultValue: Record<string, unknown>;
-    /** @see QueryFormSignals.activeFilterCount */
-    activeFilterCount: Signal<number>;
-    /** Whether every field sits at its default. */
-    isAtDefaults: Signal<boolean>;
-    /** Whether a change is waiting out its debounce, so the committed value is one edit behind. */
-    isCommitPending: Signal<boolean>;
-    /** Whether the form is syncing with the URL, i.e. whether `observe()` has been called. */
-    isObserving: Signal<boolean>;
-    resetField: (key: string) => void;
-    resetAll: () => void;
-};
-
-/**
- * The kind of object a {@link QueryDevtoolsEntry} describes. Part of the devtools contract consumed
- * by `<et-query-devtools>` - not a general-purpose query API.
- */
-type QueryDevtoolsEntryKind = 'query' | 'query-stack' | 'paged-query-stack' | 'query-sequence' | 'query-batch' | 'auth-provider' | 'ws-client' | 'query-form';
-/**
- * One chunk of a parsed query route: either literal text (`param: null`) or a path param, whose name
- * is in {@link QueryDevtoolsRoutePart.text}. Lets the devtools tell a route's static parts from its
- * dynamic ones and fill the latter in with the values a query actually used.
- */
-type QueryDevtoolsRoutePart = {
-    text: string;
-    param: string | null;
-};
-/**
- * One of a bearer auth provider's queries, described without instantiating it - which is what lets
- * tooling build the token-refresh request of a provider whose refresh query has not run yet.
- */
-type QueryDevtoolsAuthQuery = {
-    key: string;
-    /** `token-refresh` for the query registered via `withRefreshQuery`, `auth` for the rest. */
-    kind: 'auth' | 'token-refresh';
-    method: string;
-    /** Stringified route with path params rendered as `:name`. */
-    route: string;
-    /** The args a token refresh sends for a given refresh token. Only set on the refresh query. */
-    buildArgs?: (refreshToken: string) => {
-        body?: unknown;
-    };
-};
-/**
- * Descriptive, mostly-static metadata about a registered devtools entry. The live, reactive state
- * is read from the entry's {@link QueryDevtoolsEntry.handle} instead.
- */
-type QueryDevtoolsEntryMeta = {
-    /** Display name of the owning query client, where known. */
-    clientName?: string;
-    /** Base URL of the owning query client, where known. */
-    clientBaseUrl?: string;
-    /** Human readable display name (e.g. an auth provider or web socket client name). */
-    name?: string;
-    /** The connection URL, for web socket clients. */
-    url?: string;
-    /** The GraphQL document string, for GraphQL queries. */
-    gqlQuery?: string;
-    /** Stringified route with path params rendered as `:name`, for queries. */
-    route?: string;
-    /** The same route, split into its literal and path-param parts. */
-    routeParts?: QueryDevtoolsRoutePart[];
-    /** Human readable HTTP/GQL method, for queries (e.g. `GET`, `GQL QUERY`). */
-    method?: string;
-    /** The features applied at creation, with the options each was configured with. */
-    features?: QueryDevtoolsFeature[];
-    /** Whether the query authenticates through a bearer auth provider, for queries. */
-    isSecure?: boolean;
-    /** Name of the bearer auth provider a secure query authenticates with. */
-    authProviderName?: string;
-    /** The provider's own queries, for auth providers. */
-    authQueries?: QueryDevtoolsAuthQuery[];
-    /**
-     * The batch that created a query, for the one query `createQueryBatch` runs per item. The panel folds
-     * such queries under their batch's own entry instead of listing a row per item, and the registry caps
-     * their tombstones per batch so a bulk run cannot evict everything else it kept.
-     */
-    batch?: QueryBatchDevtoolsHandle;
-    /** Which of the batch's items the query was created for, for a batch's item query. */
-    batchItemIndex?: number;
-    /** How many of a batch's requests may be in flight at once, for batches. */
-    concurrency?: number;
-    /** Whether a batch's first failure stops the rest of the run, for batches. */
-    stopOnError?: boolean;
-    /** The query config passed at creation, for queries. */
-    queryConfig?: QueryConfig;
-    /** The creator options passed at creation, for queries. */
-    creator?: CreateQueryCreatorOptions;
-    /** The owning client's repository, where known (queries and auth providers). */
-    repository?: QueryRepository;
-    /**
-     * The owning client itself, where known (queries and auth providers). Read for state that hangs off
-     * the client rather than the repository - the multi-tab sync engine, in particular.
-     */
-    client?: QueryClient;
-    /**
-     * The DOM element of the component/directive that created a query, when available. Used by the
-     * devtools "inspect" tool to map a query back to its place in the live UI.
-     */
-    element?: HTMLElement | null;
-};
-/**
- * A single entry in the {@link queryDevtoolsEntries} registry. The `handle` is the live object
- * (query, stack, sequence or auth provider) so its signals stay reactive when read by the UI.
- */
-type QueryDevtoolsEntry = {
-    id: string;
-    kind: QueryDevtoolsEntryKind;
-    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.
-     */
-    stats?: QueryDevtoolsStatsHandle;
-    /** The query forms this entry's args read, for queries created with a `withArgs` feature. */
-    formLinks?: QueryDevtoolsFormLinksHandle;
-    /**
-     * The response overrides armed on this entry, for queries. Unlike {@link stats}/{@link formLinks} -
-     * whose write side is internal instrumentation the panel only ever reads - the panel itself is what
-     * arms an override, so this exposes the full recorder rather than a read-only handle.
-     */
-    overrides?: QueryDevtoolsOverridesRecorder;
-};
-/**
- * What an instrumentation site hands to the registry. Raw values (`route`, `clientRef`) are rendered
- * into {@link QueryDevtoolsEntryMeta} by the registry rather than at the call site, so the code that
- * renders them is only reachable from {@link provideQueryDevtools}.
+ * What an instrumentation site hands to the registry. Raw values (`route`, `clientRef`) are rendered
+ * into {@link QueryDevtoolsEntryMeta} by the registry rather than at the call site, so the code that
+ * renders them is only reachable from {@link provideQueryDevtools}.
  */
 type QueryDevtoolsRegistration = {
     id?: string;
@@ -5999,483 +6018,717 @@ type QueryDevtoolsAuthSeed = {
 };
 
 /**
- * Whether the client that owns a repository is still alive. A destroyed client's queries survive as
- * tombstones, which keep their `meta.repository`, so this is the only way to tell a dead client from
- * one whose queries all happen to be destroyed.
+ * How an application hands its API description to the devtools, so a designed mock can start from the
+ * real shape of a response instead of a guess. TypeScript types are erased at runtime, so a generated
+ * `.d.ts` is not readable from here - the document the types were generated *from* is.
  *
- * Reads a version signal, so a computed that calls it recomputes as clients come and go.
+ * OpenAPI 3.x, Swagger 2 and a bare JSON Schema document all work: named schemas are read from
+ * `components.schemas`, `definitions` or `$defs`, and routes from `paths`.
  *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * The loader is called at most once, and only when the panel first asks for it - so returning a dynamic
+ * `import()` keeps the document out of the application bundle entirely.
+ *
+ * @example
+ * ```ts
+ * provideQueryDevtools({ schema: () => import('../openapi.json') })
+ * provideQueryDevtools({ schema: () => fetch('/openapi.json').then((res) => res.json()) })
+ * ```
  */
-declare const isQueryDevtoolsRepositoryLive: (repository: QueryRepository) => boolean;
-
+type QueryDevtoolsSchemaLoader = () => Promise<unknown> | unknown;
 /**
- * A response designed in the devtools panel and served in place of a request. An override edits what came
- * back; a mock replaces the request itself, so it can be armed for a route that has never run - or does
- * not exist yet.
+ * The description each query client is served by. One loader describes every client - which is what a
+ * single-API application wants - and a record keyed by client name (the `name` a client was created
+ * with) describes them one API at a time, so a mock designed against one client never offers another
+ * one's routes.
+ *
+ * @example
+ * ```ts
+ * provideQueryDevtools({
+ *   schema: {
+ *     hubApiClient: () => import('../hub-openapi.json'),
+ *     votingApiClient: () => fetch('/voting/openapi.json').then((res) => res.json()),
+ *   },
+ * })
+ * ```
  */
-type QueryDevtoolsMock = {
-    /** `clientName|method|pattern` - stable across reloads, and what the armed set holds. */
-    id: string;
-    /** Display name of the query client this is served for. */
-    clientName: string;
+type QueryDevtoolsSchemaLoaders = QueryDevtoolsSchemaLoader | Record<string, QueryDevtoolsSchemaLoader>;
+/**
+ * Where the API description stands. `unavailable` means the application never handed one in, which is
+ * what the panel shows the seeding controls on.
+ */
+type QueryDevtoolsSchemaState = {
+    status: 'unavailable';
+} | {
+    status: 'idle';
+} | {
+    status: 'loading';
+} | {
+    status: 'ready';
+} | {
+    status: 'error';
+    message: string;
+};
+/** One route the description declares, whether or not the application has ever called it. */
+type QueryDevtoolsSchemaRoute = {
     method: string;
-    /** The route with its path params as `:name`, matched against a request's path. */
+    /** The route with its path params as `:name`, so it reads the way a mock's pattern does. */
     pattern: string;
+    /** The operation's summary, its `operationId`, or empty - whatever the document offers as a label. */
+    summary: string;
+};
+/**
+ * A body generated from the description, plus everything that could not be read off it with certainty.
+ * A seed is a starting point for the designer, never a claim about what the API returns.
+ */
+type QueryDevtoolsSchemaSeed = {
+    body: unknown;
+    /** The named schema the body was generated from, when the document named one. */
+    schemaName: string | null;
     /**
-     * Query parameters the request must carry for this mock to answer it, as a query string
-     * (`page=2&limit=10`). Every declared pair has to match; anything else on the request is ignored. Empty
-     * matches whatever the request asks for.
+     * The declared type of each field, keyed by its path with array indices as `*` (`items.*.id`) - so one
+     * entry annotates every element of an array, however many the designer goes on to add.
      */
-    query: string;
-    /** The status the mock responds with. `400` and above arrive as an `HttpErrorResponse`. */
-    status: number;
-    body: unknown;
-    /** Delay before the mocked response settles, so a mocked route still has a loading state. */
-    latencyMs: number;
-    /** When the body was captured from a real response, or `null` if it was authored from nothing. */
-    capturedAt: number | null;
+    types: ReadonlyMap<string, string>;
+    /** What had to be guessed, skipped or cut short, so a seeded body is never mistaken for the contract. */
+    notes: readonly string[];
+};
+/**
+ * How lifelike a seeded body is. `placeholder` names every field after itself, so a seed reads as
+ * obviously unreal; `realistic` fills it with varied sample values, so a list is not three identical
+ * rows; `stress` fills it with what a layout breaks on - long unbreakable words, unicode, huge numbers.
+ */
+type QueryDevtoolsSeedStyle = 'placeholder' | 'realistic' | 'stress';
+/**
+ * Where the description of one query client's API stands, for the panel's seeding controls.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsSchemaState: (clientName: string) => QueryDevtoolsSchemaState;
+/**
+ * Loads the API description, once. Calling it while it is loading or after it has loaded does nothing;
+ * calling it after a failure retries.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const loadQueryDevtoolsSchema: (clientName: string) => void;
+/**
+ * Every schema one client's description names, sorted - the designer's "seed from a type" list.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsSchemaNames: (clientName: string) => readonly string[];
+/**
+ * Generates a body from one schema the client's description names (`MatchView`), or `null` when it names
+ * no such thing. The style decides how lifelike its values are; the shape is the same either way.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const seedQueryDevtoolsSchemaBody: (clientName: string, name: string, style?: QueryDevtoolsSeedStyle) => QueryDevtoolsSchemaSeed | null;
+/** Everything a set of named schemas needs to resolve on its own, lifted out of the description. */
+type QueryDevtoolsSchemaComponents = {
     /**
-     * The schema the body was seeded from, when it came from the application's API description - so the
-     * designer can label its fields with their declared types again after a reload.
+     * The named schemas plus everything they transitively `$ref`, keyed as `components.schemas` wants
+     * them. A name the description does not declare is simply absent, which is what a caller checks.
      */
-    schemaName?: string | null;
+    schemas: Record<string, unknown>;
+    /** Refs that could not be brought along, so an exported document says why it does not resolve. */
+    notes: readonly string[];
 };
-/** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
-declare const queryDevtoolsMocks: Signal<readonly QueryDevtoolsMock[]>;
 /**
- * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
- * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
+ * Collects the named schemas a set of routes was designed against, ready to be handed back as the
+ * `components.schemas` of an exported document - so a route seeded from `MatchView` can reference
+ * `MatchView` instead of an anonymous shape inferred from one body.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const queryDevtoolsArmedMocks: Signal<ReadonlySet<string>>;
+declare const collectQueryDevtoolsSchemaComponents: (clientName: string, names: readonly string[]) => QueryDevtoolsSchemaComponents;
 /**
- * Whether what is armed right now came back from a previous page load rather than being armed by hand.
- * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
+ * Every route one client's description declares, as the designer offers them - including the ones no
+ * query has ever called, which is the case a mock exists for.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const queryDevtoolsArmedMocksRestored: Signal<boolean>;
+declare const queryDevtoolsSchemaRoutes: (clientName: string) => readonly QueryDevtoolsSchemaRoute[];
 /**
- * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
- * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
+ * Generates a body for one route from the description's own success response - the seed that makes a
+ * designed mock a real view model rather than a guess. `null` when the document does not declare the
+ * route, or declares no JSON response for it.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const queryDevtoolsMockId: (parts: Pick<QueryDevtoolsMock, "clientName" | "method" | "pattern"> & {
-    query?: string;
-}) => string;
+declare const seedQueryDevtoolsSchemaRoute: (target: {
+    clientName: string;
+    method: string;
+    pattern: string;
+}, style?: QueryDevtoolsSeedStyle) => QueryDevtoolsSchemaSeed | null;
+
 /**
- * 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.
+ * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
  */
-declare const queryDevtoolsRequestPath: (url: string, baseUrl?: string) => string;
+declare const queryDevtoolsEntries: Signal<QueryDevtoolsEntry[]>;
+/** Renders parsed route parts as a template, e.g. `/team/:teamId/players`. */
+declare const stringifyQueryRouteParts: (parts: QueryDevtoolsRoutePart[]) => string;
+/**
+ * Forgets destroyed entries the registry is holding - the panel's "clear gone" action. Pass the ids to
+ * drop to forget only those; with no argument every tombstone goes. Live entries are untouched.
+ */
+declare const clearQueryDevtoolsTombstones: (ids?: Iterable<string>) => 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.
+     *
+     * This is the default; the panel's Settings tab can raise it for the rest of a page.
+     */
+    responseHistory?: number;
+    /**
+     * Build information about the application - version, commit SHA, environment name. Shown on the
+     * panel's About tab, included in the session export and exposed on `window.ethlete`, so a bug report
+     * says which build it came from. Generate it rather than typing it:
+     * `nx g @ethlete/core:devtools-about <app>`.
+     */
+    about?: QueryDevtoolsAppInfo;
+    /**
+     * The OpenAPI (or JSON Schema) document behind each query client, so the panel's mock designer can
+     * seed a response from the real shape of a route and label each field with the type it is declared as.
+     * One loader describes every client; a record keyed by client name describes an application whose
+     * clients speak to different APIs. Each loader runs at most once, and only when the designer first
+     * asks for it - see {@link QueryDevtoolsSchemaLoaders}.
+     */
+    schema?: QueryDevtoolsSchemaLoaders;
+    /**
+     * The backends this application can be pointed at, one entry per `localStorage` key it reads at
+     * startup. Declaring them puts a picker next to the floating toggle and on the panel's Settings tab;
+     * picking writes the key and reloads. Nothing else changes - the application still resolves the key
+     * itself, so an env is whatever it already means to it.
+     */
+    apiEnvs?: QueryDevtoolsApiEnvSwitch[];
+    /**
+     * The accounts the panel may log in as, so a session can be switched without typing a login form
+     * again. Declare the slot only - the label, the query and the fields it needs. Whoever runs the app
+     * types the credentials into the panel once, and they stay in that browser: **never put a password in
+     * the repository.**
+     *
+     * Scope an account to the backends it exists on with `envs`, for an API whose users are not the next
+     * one's. Accounts are not offered at all while an `apiEnvs` env marked `production` is the pick.
+     */
+    authAccounts?: QueryDevtoolsAuthAccount[];
+};
 /**
- * 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.
+ * 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
+ * appear in the `<et-query-devtools>` panel.
+ *
+ * When omitted, all devtools instrumentation is a no-op: the registry is never installed, so nothing
+ * is retained at runtime and the registry itself is dropped from the bundle.
+ *
+ * The options are read once, on the first call. A second application on the same page keeps the
+ * options of the first one, and this call warns about the ones it declared itself.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideQueryDevtools()],
+ * });
+ * ```
  */
-declare const matchesQueryDevtoolsMockQuery: (declared: string, url: string) => boolean;
+declare const provideQueryDevtools: (options?: QueryDevtoolsOptions) => EnvironmentProviders;
+
 /**
- * Whether a request path is the route a pattern describes. A `:param` segment matches any single
- * non-empty segment, which is the whole point: a mock is armed for a route, not for the one URL a query
- * happened to build.
+ * The longest lifetime an armed override may claim, in seconds (7 days). Anything beyond it is never
+ * refreshed at all, which is what arming nothing already does.
  */
-declare const matchesQueryDevtoolsMockPattern: (pattern: string, path: string) => boolean;
+declare const QUERY_DEVTOOLS_TOKEN_TTL_LIMIT = 604800;
 /**
- * Adds a designed mock, or replaces the one already under its id. Arming is untouched: re-designing a
- * body while it is being served changes what the next request gets.
+ * The access-token lifetime armed per auth provider name, in seconds, consumed by the
+ * `<et-query-devtools>` panel. A provider on its token's real lifetime is absent rather than present
+ * with it.
  */
-declare const saveQueryDevtoolsMock: (mock: QueryDevtoolsMock) => void;
-/** Removes a designed mock, disarming it on the way out. */
-declare const deleteQueryDevtoolsMock: (id: string) => void;
-/** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
-declare const armQueryDevtoolsMock: (id: string, isArmed: boolean) => void;
-/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
-declare const armAllQueryDevtoolsMocks: () => void;
-/** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
-declare const clearQueryDevtoolsArmedMocks: () => void;
+declare const queryDevtoolsTokenTtls: Signal<Record<string, number>>;
 /**
- * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
- * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
- * exactly what it was already serving.
+ * Whether an overridden lifetime can be applied to a decoded access token at all. It needs the claim
+ * carrying the expiry - so a lifetime is never invented for a token that declares none - plus `iat` or
+ * `nbf` to measure the new lifetime from.
  */
-declare const setQueryDevtoolsArmedMocksScope: (next: QueryDevtoolsStorageScope) => void;
-/** Empties the designed library and disarms everything - the panel's "Reset devtools". */
-declare const clearQueryDevtoolsMockStore: () => void;
-
-/** One entry id the last page load left ops for, as the panel's banner reports it. */
-type RestoredQueryDevtoolsOverrides = {
-    /** The devtools entry id the ops were stored under. */
-    id: string;
-    /** How many ops were stored for it. */
-    count: number;
-    /**
-     * Whether a query with this id has registered and taken them. `false` means the store outlived the
-     * query it was written for - a route that no longer runs, or a creation order that shifted - so those
-     * ops are sitting on nothing rather than quietly landing somewhere else.
-     */
-    armed: boolean;
-};
+declare const canOverrideQueryDevtoolsTokenTtl: (options: {
+    payload: Record<string, unknown> | null;
+    expiresInPropertyName?: string;
+}) => boolean;
 /**
- * Whether armed response overrides are stored and replayed on the next page load - that is, whether
- * their scope is anything other than `none`. Off by default.
+ * Presents one auth provider's access token as living `seconds` from the moment it was issued, rather
+ * than as long as it says it does. Everything that reads the expiry sees the shortened lifetime - the
+ * proactive refresh schedule, `withBearerAuthTokenExpirationWarning`, and the panel's own countdown -
+ * so arming 60 seconds makes a real refresh happen a minute after each token is issued, and keeps
+ * happening for every token that refresh brings back.
+ *
+ * It is a lifetime, not a remaining time: `0` presents the current token as long expired, which is what
+ * makes a refresh happen at once. Nothing is persisted, so a reload leaves every provider on its real
+ * lifetime.
+ *
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a token's lifetime is not something
+ * an application should override on itself.
  */
-declare const queryDevtoolsOverridePersistence: Signal<boolean>;
+declare const setQueryDevtoolsTokenTtl: (options: {
+    providerName: string;
+    seconds: number;
+}) => void;
 /**
- * Where armed response overrides are kept. Switching to a scope that keeps them captures whatever is
- * armed right now, so the choice reads as "keep these" rather than "keep the next ones"; switching
- * between `session` and `local` moves the store; switching to `none` empties it and leaves every armed
- * op exactly where it is for the rest of this page.
+ * Puts one provider back on its token's real lifetime, or every provider when no name is given.
+ *
+ * @see setQueryDevtoolsTokenTtl
  */
-declare const setQueryDevtoolsOverridesScope: (next: QueryDevtoolsStorageScope) => void;
+declare const clearQueryDevtoolsTokenTtl: (providerName?: string) => void;
 /**
- * Turns persistence on or off - the panel's "Keep across reloads" toggle. On restores the last scope
- * that kept them (`session` unless Settings picked `local`).
+ * The decoded access token as the devtools want it seen: the claim carrying the expiry rewritten to the
+ * armed lifetime, measured from `iat`. Returns `payload` untouched when nothing is armed for the
+ * provider, or when the token cannot carry the override - see {@link canOverrideQueryDevtoolsTokenTtl}.
+ *
+ * Installed as the token payload patcher by `provideQueryDevtools()`, and called directly by the panel
+ * for its own countdown.
  */
-declare const setQueryDevtoolsOverridePersistence: (value: boolean) => void;
+declare const applyQueryDevtoolsTokenTtl: <T>(options: {
+    payload: T;
+    providerName: string;
+    expiresInPropertyName?: string;
+}) => T;
+
 /**
- * Empties the override store in both browser stores and disarms everything a reload brought back,
- * without changing where overrides are kept - the panel's "Reset devtools".
+ * Whether a devtools UI is on the page, which is what the floating pills follow. Kept apart from the
+ * pills themselves so `@ethlete/query-devtools/toggle` can declare itself without pulling the pill
+ * renderer into the bundle an application ships.
  */
-declare const clearQueryDevtoolsOverrideStore: () => void;
 /**
- * The ops this page load inherited from the previous one, and for each id whether a live query has taken
- * it. Overrides that outlive the page that armed them have to announce themselves, because an app being
- * lied to looks exactly like an app that is broken.
+ * Declares a devtools UI on the page, and takes the declaration back when it goes. The floating pills
+ * paint only while one is mounted, so an application that renders no devtools trigger shows no pills
+ * either.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const restoredQueryDevtoolsOverrides: Signal<readonly RestoredQueryDevtoolsOverrides[]>;
+declare const setQueryDevtoolsUiMounted: (isMounted: boolean) => void;
+
 /**
- * The scope those ops came back from, or `null` when this page inherited none. `local` is the one worth
- * naming in the banner: it means they outlived closing the tab, not just a reload.
+ * Where one kind of devtools state is kept between page loads. `none` means it is not kept at all -
+ * what that costs differs per kind, which is why every kind picks its own.
  */
-declare const queryDevtoolsRestoredOverridesScope: Signal<QueryDevtoolsStorageScope | null>;
-/** Disarms every op this page load inherited and empties the store - the banner's one-click way out. */
-declare const clearRestoredQueryDevtoolsOverrides: () => void;
-
-declare const TRANSFER_KIND = "ethlete-query-overrides";
+type QueryDevtoolsStorageScope = 'none' | 'session' | 'local';
 /**
- * A whole armed override set, as the devtools panel writes it to the clipboard: pretty-printed JSON so
- * it can be pasted onto another query, into a ticket, or hand-edited on the way. `source` is only ever
- * a human's bearing on where it came from - a paste never resolves against it.
+ * The devtools' own configuration: where each kind of panel state is kept, and the limits the panel
+ * would otherwise hold as constants. Read it as {@link queryDevtoolsSettings}, change it with
+ * {@link setQueryDevtoolsSettings}.
  */
-type QueryDevtoolsOverrideTransfer = {
-    kind: typeof TRANSFER_KIND;
-    version: number;
-    source?: {
-        id?: string;
-        url?: string;
-    };
-    ops: OverrideOp[];
-};
-/** What {@link parseQueryDevtoolsOverrideTransfer} makes of a piece of clipboard text. */
-type QueryDevtoolsOverrideTransferParse = {
-    ok: true;
-    ops: OverrideOp[];
-    /** Ops the payload held that this build has no `type` for - a newer panel wrote them. */
-    skipped: number;
-    source?: {
-        id?: string;
-        url?: string;
-    };
-} | {
-    ok: false;
-    reason: string;
+type QueryDevtoolsSettings = {
+    /** Panel chrome and view state: dock, sizes, open tab, filters, selections. */
+    viewState: QueryDevtoolsStorageScope;
+    /** The entry ids sorted to the top of the Queries list. */
+    pins: QueryDevtoolsStorageScope;
+    /**
+     * Armed response overrides, replayed as queries register on the next load. `none` by default: an app
+     * that stays tampered with across reloads is hours of debugging the wrong thing.
+     */
+    overrides: QueryDevtoolsStorageScope;
+    /** The library of designed mocks - the authoring, not whether any of them is armed. */
+    mocks: QueryDevtoolsStorageScope;
+    /**
+     * Which mocks are **armed**, as opposed to the library above. `none` by default: an app that silently
+     * serves designed data tomorrow morning is worse than arming them again, so keeping them is a choice
+     * someone makes rather than the way the panel ships.
+     */
+    armedMocks: QueryDevtoolsStorageScope;
+    /** The faults armed per client, for the same reason and with the same default. */
+    armedFaults: QueryDevtoolsStorageScope;
+    /**
+     * The session vault: the token pairs the panel switches between, and the credentials it logs in with.
+     * `local` by default, because a vault that forgets the other user on every reload is not one - and
+     * `none` for a machine where nothing of the sort may be kept. Outside a development build `local` is
+     * refused and read back as `none`, see {@link queryDevtoolsAllowsLocalAuthSessions}.
+     */
+    authSessions: QueryDevtoolsStorageScope;
+    /** How many entries the Events log keeps. */
+    maxEvents: number;
+    /** How many dropped cache entries the Cache tab remembers, per client. */
+    maxDroppedCacheEntries: number;
+    /**
+     * How many bodies each query retains, overriding `provideQueryDevtools({ responseHistory })` for the
+     * rest of this page. `null` leaves the application's value alone.
+     */
+    responseHistory: number | null;
+    /**
+     * Whether switching to another session reloads the page. On by default: a switch replaces what the
+     * query layer holds, and an application that keeps the user anywhere else - a profile service, the
+     * router, an open form - is still showing the last one until it boots again.
+     */
+    reloadOnAuthSwitch: boolean;
 };
 /**
- * Serializes the ops armed on one query into clipboard text. `reset` never reaches a recorder's list, so
- * what comes out is exactly what a paste can put back.
+ * How the devtools are configured. Every consumer reads the live value rather than a copy, so a change
+ * in the panel's Settings takes effect without a reload.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const serializeQueryDevtoolsOverrideTransfer: (entries: readonly QueryDevtoolsOverrideEntry[], source?: {
-    id?: string;
-    url?: string;
-}) => string;
+declare const queryDevtoolsSettings: Signal<QueryDevtoolsSettings>;
 /**
- * Reads clipboard text back into ops. A bare array of ops is accepted alongside the full envelope, so a
- * set pasted out of a ticket and trimmed by hand still lands; an op whose `type` this build doesn't know
- * is counted in `skipped` rather than failing the whole paste, so an older panel can take a newer one's
- * set minus the parts it cannot replay.
+ * The `Storage` a scope names, or `null` for `none` and for a browser that refuses one (private mode,
+ * storage disabled, server-side rendering). Callers treat "no storage" and "not persisted" alike.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const parseQueryDevtoolsOverrideTransfer: (text: string) => QueryDevtoolsOverrideTransferParse;
+declare const queryDevtoolsStorage: (scope: QueryDevtoolsStorageScope) => Storage | null;
 /**
- * How many of `ops` would not resolve against `raw` - what a paste onto a differently-shaped query
- * reports, so ops sitting on nothing say so instead of looking armed. Replays them the same way the
- * pipeline will, since an earlier op can be what makes a later one's path exist.
+ * Reads one JSON-encoded devtools key from the store a scope names, or `null`.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const countUnresolvedQueryDevtoolsOverrides: (ops: readonly OverrideOp[], raw: unknown) => number;
-/** Arms every op of a parsed set onto a query, on top of whatever it already has armed. */
-declare const armQueryDevtoolsOverrideTransfer: (recorder: QueryDevtoolsOverridesRecorder, ops: readonly OverrideOp[]) => void;
-
+declare const readQueryDevtoolsStore: <T>(scope: QueryDevtoolsStorageScope, key: string) => T | null;
 /**
- * How an application hands its API description to the devtools, so a designed mock can start from the
- * real shape of a response instead of a guess. TypeScript types are erased at runtime, so a generated
- * `.d.ts` is not readable from here - the document the types were generated *from* is.
- *
- * OpenAPI 3.x, Swagger 2 and a bare JSON Schema document all work: named schemas are read from
- * `components.schemas`, `definitions` or `$defs`, and routes from `paths`.
+ * Writes one devtools key into the store a scope names. A scope of `none` writes nothing.
  *
- * The loader is called at most once, and only when the panel first asks for it - so returning a dynamic
- * `import()` keeps the document out of the application bundle entirely.
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const writeQueryDevtoolsStore: (scope: QueryDevtoolsStorageScope, key: string, value: unknown) => void;
+/**
+ * Removes one devtools key from **both** stores, whatever the scope currently is - so a scope that
+ * changed cannot leave a stale copy behind for the next load to read.
  *
- * @example
- * ```ts
- * provideQueryDevtools({ schema: () => import('../openapi.json') })
- * provideQueryDevtools({ schema: () => fetch('/openapi.json').then((res) => res.json()) })
- * ```
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-type QueryDevtoolsSchemaLoader = () => Promise<unknown> | unknown;
+declare const clearQueryDevtoolsStore: (key: string) => void;
 /**
- * The description each query client is served by. One loader describes every client - which is what a
- * single-API application wants - and a record keyed by client name (the `name` a client was created
- * with) describes them one API at a time, so a mock designed against one client never offers another
- * one's routes.
+ * Whether the session vault may be kept in `localStorage`. Only a development build may: the vault
+ * holds live access and refresh tokens plus the credentials somebody typed in, and a deployed
+ * application that mounts the panel for its debugging value must not leave those on the machine of
+ * whoever opened it. Outside a development build a stored or default `local` reads back as `none`, so a
+ * plain login keeps nothing; `session` stays on offer for whoever picks it in Settings.
  *
- * @example
- * ```ts
- * provideQueryDevtools({
- *   schema: {
- *     hubApiClient: () => import('../hub-openapi.json'),
- *     votingApiClient: () => fetch('/voting/openapi.json').then((res) => res.json()),
- *   },
- * })
- * ```
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-type QueryDevtoolsSchemaLoaders = QueryDevtoolsSchemaLoader | Record<string, QueryDevtoolsSchemaLoader>;
+declare const queryDevtoolsAllowsLocalAuthSessions: () => boolean;
 /**
- * Where the API description stands. `unavailable` means the application never handed one in, which is
- * what the panel shows the seeding controls on.
+ * Changes part of the devtools configuration and stores it. Values outside the range a field allows are
+ * clamped rather than rejected.
+ *
+ * Overrides are the one field not to set here: their scope moves an existing store, so it goes through
+ * `setQueryDevtoolsOverridesScope()` instead.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
  */
-type QueryDevtoolsSchemaState = {
-    status: 'unavailable';
-} | {
-    status: 'idle';
-} | {
-    status: 'loading';
-} | {
-    status: 'ready';
-} | {
-    status: 'error';
-    message: string;
-};
-/** One route the description declares, whether or not the application has ever called it. */
-type QueryDevtoolsSchemaRoute = {
-    method: string;
-    /** The route with its path params as `:name`, so it reads the way a mock's pattern does. */
-    pattern: string;
-    /** The operation's summary, its `operationId`, or empty - whatever the document offers as a label. */
-    summary: string;
-};
+declare const setQueryDevtoolsSettings: (patch: Partial<QueryDevtoolsSettings>) => void;
+
 /**
- * A body generated from the description, plus everything that could not be read off it with certainty.
- * A seed is a starting point for the designer, never a claim about what the API returns.
+ * A fault armed on one query client from the devtools panel. Unlike the panel's forced states - which
+ * write a query's signals directly - an armed fault is applied inside the request pipeline, so retries,
+ * error handling features and the cache all see it exactly as they would see a real one.
  */
-type QueryDevtoolsSchemaSeed = {
-    body: unknown;
-    /** The named schema the body was generated from, when the document named one. */
-    schemaName: string | null;
+type QueryDevtoolsFault = {
+    /** Extra latency in ms added before every attempt starts. `0` disables it. */
+    latencyMs: number;
     /**
-     * The declared type of each field, keyed by its path with array indices as `*` (`items.*.id`) - so one
-     * entry annotates every element of an array, however many the designer goes on to add.
+     * How many upcoming attempts fail before the client is let through again, counted down as they are
+     * consumed. `0` disables it.
      */
-    types: ReadonlyMap<string, string>;
-    /** What had to be guessed, skipped or cut short, so a seeded body is never mistaken for the contract. */
-    notes: readonly string[];
+    failNext: number;
+    /** The percentage of attempts that fail, rolled per attempt. `0` disables it, `100` fails everything. */
+    failRate: number;
+    /** The status an injected failure responds with. */
+    status: number;
 };
+/** The neutral fault: nothing armed. */
+declare const EMPTY_QUERY_DEVTOOLS_FAULT: QueryDevtoolsFault;
 /**
- * How lifelike a seeded body is. `placeholder` names every field after itself, so a seed reads as
- * obviously unreal; `realistic` fills it with varied sample values, so a list is not three identical
- * rows; `stress` fills it with what a layout breaks on - long unbreakable words, unicode, huge numbers.
+ * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
+ * this cannot arm a 500 and then leave you wondering why no retry fired.
+ * @see runDefaultQueryRetry
  */
-type QueryDevtoolsSeedStyle = 'placeholder' | 'realistic' | 'stress';
+declare const QUERY_DEVTOOLS_FAULT_STATUSES: {
+    status: number;
+    label: string;
+    retryable: boolean;
+}[];
 /**
- * Where the description of one query client's API stands, for the panel's seeding controls.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
+ * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
  */
-declare const queryDevtoolsSchemaState: (clientName: string) => QueryDevtoolsSchemaState;
+declare const queryDevtoolsFaults: Signal<Record<string, QueryDevtoolsFault>>;
 /**
- * Loads the API description, once. Calling it while it is loading or after it has loaded does nothing;
- * calling it after a failure retries.
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because injected failures nobody remembers arming look exactly like a
+ * broken API.
+ */
+declare const queryDevtoolsFaultsRestored: Signal<boolean>;
+/**
+ * Where the armed faults are kept. Switching to a scope that keeps them stores whatever is armed right
+ * now; switching to `none` empties the store and leaves this page's faults exactly where they are.
+ */
+declare const setQueryDevtoolsFaultsScope: (next: QueryDevtoolsStorageScope) => void;
+/** Whether anything at all is armed on a fault. */
+declare const isQueryDevtoolsFaultArmed: (fault: QueryDevtoolsFault) => boolean;
+/**
+ * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
+ * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
  *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
+ * something an application should arm on itself.
  */
-declare const loadQueryDevtoolsSchema: (clientName: string) => void;
+declare const setQueryDevtoolsFault: (options: {
+    clientName: string;
+    patch: Partial<QueryDevtoolsFault>;
+}) => void;
 /**
- * Every schema one client's description names, sorted - the designer's "seed from a type" list.
+ * Disarms every fault of one client, or of all clients when no name is given.
  *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * @see setQueryDevtoolsFault
  */
-declare const queryDevtoolsSchemaNames: (clientName: string) => readonly string[];
+declare const clearQueryDevtoolsFaults: (clientName?: string) => void;
+
 /**
- * Generates a body from one schema the client's description names (`MatchView`), or `null` when it names
- * no such thing. The style decides how lifelike its values are; the shape is the same either way.
+ * One field of a query form, as the devtools panel reads it: what it holds, what it puts in the URL,
+ * and the rules that decide when either changes.
+ */
+type QueryDevtoolsFormField = {
+    key: string;
+    /** The query-param key the field serializes to, with the form's prefix applied. */
+    paramKey: string;
+    /** The committed value - what the query args are built from. */
+    value: unknown;
+    /** The live value of the bound control, which differs from {@link value} while a debounce is pending. */
+    liveValue: unknown;
+    defaultValue: unknown;
+    /** Whether the committed value is the default one. */
+    isDefault: boolean;
+    /** What the field writes to the URL, or `undefined` when it writes nothing. */
+    queryParam: unknown;
+    /** How long a change waits before it is committed, or `null` when it commits immediately. */
+    debounceMs: number | null;
+    /** The sibling fields whose change resets this one back to its default. */
+    isResetBy: readonly string[];
+    /** Whether the field counts towards {@link QueryDevtoolsFormHandle.activeFilterCount}. */
+    countsAsFilter: boolean;
+};
+/**
+ * The live state of a query form, as `<et-query-devtools>` renders it. Part of the devtools contract -
+ * not a general-purpose query-form API.
+ */
+type QueryDevtoolsFormHandle = {
+    fields: Signal<QueryDevtoolsFormField[]>;
+    /** The committed value of the whole form. */
+    value: Signal<Record<string, unknown>>;
+    /** The value of every field before the most recent commit, or `null` before the first one. */
+    previousValue: Signal<Record<string, unknown> | null>;
+    defaultValue: Record<string, unknown>;
+    /** @see QueryFormSignals.activeFilterCount */
+    activeFilterCount: Signal<number>;
+    /** Whether every field sits at its default. */
+    isAtDefaults: Signal<boolean>;
+    /** Whether a change is waiting out its debounce, so the committed value is one edit behind. */
+    isCommitPending: Signal<boolean>;
+    /** Whether the form is syncing with the URL, i.e. whether `observe()` has been called. */
+    isObserving: Signal<boolean>;
+    resetField: (key: string) => void;
+    resetAll: () => void;
+};
+
+/**
+ * Whether the client that owns a repository is still alive. A destroyed client's queries survive as
+ * tombstones, which keep their `meta.repository`, so this is the only way to tell a dead client from
+ * one whose queries all happen to be destroyed.
+ *
+ * Reads a version signal, so a computed that calls it recomputes as clients come and go.
  *
  * Part of the devtools contract. **Not part of the general public contract.**
  */
-declare const seedQueryDevtoolsSchemaBody: (clientName: string, name: string, style?: QueryDevtoolsSeedStyle) => QueryDevtoolsSchemaSeed | null;
-/** Everything a set of named schemas needs to resolve on its own, lifted out of the description. */
-type QueryDevtoolsSchemaComponents = {
+declare const isQueryDevtoolsRepositoryLive: (repository: QueryRepository) => boolean;
+
+/**
+ * A response designed in the devtools panel and served in place of a request. An override edits what came
+ * back; a mock replaces the request itself, so it can be armed for a route that has never run - or does
+ * not exist yet.
+ */
+type QueryDevtoolsMock = {
+    /** `clientName|method|pattern` - stable across reloads, and what the armed set holds. */
+    id: string;
+    /** Display name of the query client this is served for. */
+    clientName: string;
+    method: string;
+    /** The route with its path params as `:name`, matched against a request's path. */
+    pattern: string;
     /**
-     * The named schemas plus everything they transitively `$ref`, keyed as `components.schemas` wants
-     * them. A name the description does not declare is simply absent, which is what a caller checks.
+     * Query parameters the request must carry for this mock to answer it, as a query string
+     * (`page=2&limit=10`). Every declared pair has to match; anything else on the request is ignored. Empty
+     * matches whatever the request asks for.
      */
-    schemas: Record<string, unknown>;
-    /** Refs that could not be brought along, so an exported document says why it does not resolve. */
-    notes: readonly string[];
+    query: string;
+    /** The status the mock responds with. `400` and above arrive as an `HttpErrorResponse`. */
+    status: number;
+    body: unknown;
+    /** Delay before the mocked response settles, so a mocked route still has a loading state. */
+    latencyMs: number;
+    /** When the body was captured from a real response, or `null` if it was authored from nothing. */
+    capturedAt: number | null;
+    /**
+     * The schema the body was seeded from, when it came from the application's API description - so the
+     * designer can label its fields with their declared types again after a reload.
+     */
+    schemaName?: string | null;
 };
+/** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
+declare const queryDevtoolsMocks: Signal<readonly QueryDevtoolsMock[]>;
 /**
- * Collects the named schemas a set of routes was designed against, ready to be handed back as the
- * `components.schemas` of an exported document - so a route seeded from `MatchView` can reference
- * `MatchView` instead of an anonymous shape inferred from one body.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
+ * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
+ */
+declare const queryDevtoolsArmedMocks: Signal<ReadonlySet<string>>;
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
+ */
+declare const queryDevtoolsArmedMocksRestored: Signal<boolean>;
+/**
+ * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
+ * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
+ */
+declare const queryDevtoolsMockId: (parts: Pick<QueryDevtoolsMock, "clientName" | "method" | "pattern"> & {
+    query?: 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 collectQueryDevtoolsSchemaComponents: (clientName: string, names: readonly string[]) => QueryDevtoolsSchemaComponents;
+declare const queryDevtoolsRequestPath: (url: string, baseUrl?: string) => string;
 /**
- * Every route one client's description declares, as the designer offers them - including the ones no
- * query has ever called, which is the case a mock exists for.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * 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.
  */
-declare const queryDevtoolsSchemaRoutes: (clientName: string) => readonly QueryDevtoolsSchemaRoute[];
+declare const matchesQueryDevtoolsMockQuery: (declared: string, url: string) => boolean;
 /**
- * Generates a body for one route from the description's own success response - the seed that makes a
- * designed mock a real view model rather than a guess. `null` when the document does not declare the
- * route, or declares no JSON response for it.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
+ * Whether a request path is the route a pattern describes. A `:param` segment matches any single
+ * non-empty segment, which is the whole point: a mock is armed for a route, not for the one URL a query
+ * happened to build.
  */
-declare const seedQueryDevtoolsSchemaRoute: (target: {
-    clientName: string;
-    method: string;
-    pattern: string;
-}, style?: QueryDevtoolsSeedStyle) => QueryDevtoolsSchemaSeed | null;
-
+declare const matchesQueryDevtoolsMockPattern: (pattern: string, path: string) => boolean;
 /**
- * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
+ * Adds a designed mock, or replaces the one already under its id. Arming is untouched: re-designing a
+ * body while it is being served changes what the next request gets.
  */
-declare const queryDevtoolsEntries: Signal<QueryDevtoolsEntry[]>;
-/** Renders parsed route parts as a template, e.g. `/team/:teamId/players`. */
-declare const stringifyQueryRouteParts: (parts: QueryDevtoolsRoutePart[]) => string;
+declare const saveQueryDevtoolsMock: (mock: QueryDevtoolsMock) => void;
+/** Removes a designed mock, disarming it on the way out. */
+declare const deleteQueryDevtoolsMock: (id: string) => void;
+/** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
+declare const armQueryDevtoolsMock: (id: string, isArmed: boolean) => void;
+/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
+declare const armAllQueryDevtoolsMocks: () => void;
+/** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
+declare const clearQueryDevtoolsArmedMocks: () => void;
 /**
- * Forgets destroyed entries the registry is holding - the panel's "clear gone" action. Pass the ids to
- * drop to forget only those; with no argument every tombstone goes. Live entries are untouched.
+ * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
+ * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
+ * exactly what it was already serving.
  */
-declare const clearQueryDevtoolsTombstones: (ids?: Iterable<string>) => 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.
-     *
-     * This is the default; the panel's Settings tab can raise it for the rest of a page.
-     */
-    responseHistory?: number;
-    /**
-     * Build information about the application - version, commit SHA, environment name. Shown on the
-     * panel's About tab, included in the session export and exposed on `window.ethlete`, so a bug report
-     * says which build it came from. Generate it rather than typing it:
-     * `nx g @ethlete/core:devtools-about <app>`.
-     */
-    about?: QueryDevtoolsAppInfo;
-    /**
-     * The OpenAPI (or JSON Schema) document behind each query client, so the panel's mock designer can
-     * seed a response from the real shape of a route and label each field with the type it is declared as.
-     * One loader describes every client; a record keyed by client name describes an application whose
-     * clients speak to different APIs. Each loader runs at most once, and only when the designer first
-     * asks for it - see {@link QueryDevtoolsSchemaLoaders}.
-     */
-    schema?: QueryDevtoolsSchemaLoaders;
-    /**
-     * The backends this application can be pointed at, one entry per `localStorage` key it reads at
-     * startup. Declaring them puts a picker next to the floating toggle and on the panel's Settings tab;
-     * picking writes the key and reloads. Nothing else changes - the application still resolves the key
-     * itself, so an env is whatever it already means to it.
-     */
-    apiEnvs?: QueryDevtoolsApiEnvSwitch[];
+declare const setQueryDevtoolsArmedMocksScope: (next: QueryDevtoolsStorageScope) => void;
+/** Empties the designed library and disarms everything - the panel's "Reset devtools". */
+declare const clearQueryDevtoolsMockStore: () => void;
+
+/** One entry id the last page load left ops for, as the panel's banner reports it. */
+type RestoredQueryDevtoolsOverrides = {
+    /** The devtools entry id the ops were stored under. */
+    id: string;
+    /** How many ops were stored for it. */
+    count: number;
     /**
-     * The accounts the panel may log in as, so a session can be switched without typing a login form
-     * again. Declare the slot only - the label, the query and the fields it needs. Whoever runs the app
-     * types the credentials into the panel once, and they stay in that browser: **never put a password in
-     * the repository.**
-     *
-     * Scope an account to the backends it exists on with `envs`, for an API whose users are not the next
-     * one's. Accounts are not offered at all while an `apiEnvs` env marked `production` is the pick.
+     * Whether a query with this id has registered and taken them. `false` means the store outlived the
+     * query it was written for - a route that no longer runs, or a creation order that shifted - so those
+     * ops are sitting on nothing rather than quietly landing somewhere else.
      */
-    authAccounts?: QueryDevtoolsAuthAccount[];
+    armed: boolean;
 };
 /**
- * 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
- * appear in the `<et-query-devtools>` panel.
- *
- * When omitted, all devtools instrumentation is a no-op: the registry is never installed, so nothing
- * is retained at runtime and the registry itself is dropped from the bundle.
- *
- * The options are read once, on the first call. A second application on the same page keeps the
- * options of the first one, and this call warns about the ones it declared itself.
- *
- * @example
- * ```ts
- * bootstrapApplication(AppComponent, {
- *   providers: [provideQueryDevtools()],
- * });
- * ```
+ * Whether armed response overrides are stored and replayed on the next page load - that is, whether
+ * their scope is anything other than `none`. Off by default.
  */
-declare const provideQueryDevtools: (options?: QueryDevtoolsOptions) => EnvironmentProviders;
-
+declare const queryDevtoolsOverridePersistence: Signal<boolean>;
 /**
- * The longest lifetime an armed override may claim, in seconds (7 days). Anything beyond it is never
- * refreshed at all, which is what arming nothing already does.
+ * Where armed response overrides are kept. Switching to a scope that keeps them captures whatever is
+ * armed right now, so the choice reads as "keep these" rather than "keep the next ones"; switching
+ * between `session` and `local` moves the store; switching to `none` empties it and leaves every armed
+ * op exactly where it is for the rest of this page.
  */
-declare const QUERY_DEVTOOLS_TOKEN_TTL_LIMIT = 604800;
+declare const setQueryDevtoolsOverridesScope: (next: QueryDevtoolsStorageScope) => void;
 /**
- * The access-token lifetime armed per auth provider name, in seconds, consumed by the
- * `<et-query-devtools>` panel. A provider on its token's real lifetime is absent rather than present
- * with it.
+ * Turns persistence on or off - the panel's "Keep across reloads" toggle. On restores the last scope
+ * that kept them (`session` unless Settings picked `local`).
  */
-declare const queryDevtoolsTokenTtls: Signal<Record<string, number>>;
+declare const setQueryDevtoolsOverridePersistence: (value: boolean) => void;
 /**
- * Whether an overridden lifetime can be applied to a decoded access token at all. It needs the claim
- * carrying the expiry - so a lifetime is never invented for a token that declares none - plus `iat` or
- * `nbf` to measure the new lifetime from.
+ * Empties the override store in both browser stores and disarms everything a reload brought back,
+ * without changing where overrides are kept - the panel's "Reset devtools".
  */
-declare const canOverrideQueryDevtoolsTokenTtl: (options: {
-    payload: Record<string, unknown> | null;
-    expiresInPropertyName?: string;
-}) => boolean;
+declare const clearQueryDevtoolsOverrideStore: () => void;
 /**
- * Presents one auth provider's access token as living `seconds` from the moment it was issued, rather
- * than as long as it says it does. Everything that reads the expiry sees the shortened lifetime - the
- * proactive refresh schedule, `withBearerAuthTokenExpirationWarning`, and the panel's own countdown -
- * so arming 60 seconds makes a real refresh happen a minute after each token is issued, and keeps
- * happening for every token that refresh brings back.
- *
- * It is a lifetime, not a remaining time: `0` presents the current token as long expired, which is what
- * makes a refresh happen at once. Nothing is persisted, so a reload leaves every provider on its real
- * lifetime.
- *
- * Part of the devtools contract consumed by `<et-query-devtools>`; a token's lifetime is not something
- * an application should override on itself.
+ * The ops this page load inherited from the previous one, and for each id whether a live query has taken
+ * it. Overrides that outlive the page that armed them have to announce themselves, because an app being
+ * lied to looks exactly like an app that is broken.
  */
-declare const setQueryDevtoolsTokenTtl: (options: {
-    providerName: string;
-    seconds: number;
-}) => void;
+declare const restoredQueryDevtoolsOverrides: Signal<readonly RestoredQueryDevtoolsOverrides[]>;
 /**
- * Puts one provider back on its token's real lifetime, or every provider when no name is given.
- *
- * @see setQueryDevtoolsTokenTtl
+ * The scope those ops came back from, or `null` when this page inherited none. `local` is the one worth
+ * naming in the banner: it means they outlived closing the tab, not just a reload.
  */
-declare const clearQueryDevtoolsTokenTtl: (providerName?: string) => void;
+declare const queryDevtoolsRestoredOverridesScope: Signal<QueryDevtoolsStorageScope | null>;
+/** Disarms every op this page load inherited and empties the store - the banner's one-click way out. */
+declare const clearRestoredQueryDevtoolsOverrides: () => void;
+
+declare const TRANSFER_KIND = "ethlete-query-overrides";
 /**
- * The decoded access token as the devtools want it seen: the claim carrying the expiry rewritten to the
- * armed lifetime, measured from `iat`. Returns `payload` untouched when nothing is armed for the
- * provider, or when the token cannot carry the override - see {@link canOverrideQueryDevtoolsTokenTtl}.
- *
- * Installed as the token payload patcher by `provideQueryDevtools()`, and called directly by the panel
- * for its own countdown.
+ * A whole armed override set, as the devtools panel writes it to the clipboard: pretty-printed JSON so
+ * it can be pasted onto another query, into a ticket, or hand-edited on the way. `source` is only ever
+ * a human's bearing on where it came from - a paste never resolves against it.
  */
-declare const applyQueryDevtoolsTokenTtl: <T>(options: {
-    payload: T;
-    providerName: string;
-    expiresInPropertyName?: string;
-}) => T;
+type QueryDevtoolsOverrideTransfer = {
+    kind: typeof TRANSFER_KIND;
+    version: number;
+    source?: {
+        id?: string;
+        url?: string;
+    };
+    ops: OverrideOp[];
+};
+/** What {@link parseQueryDevtoolsOverrideTransfer} makes of a piece of clipboard text. */
+type QueryDevtoolsOverrideTransferParse = {
+    ok: true;
+    ops: OverrideOp[];
+    /** Ops the payload held that this build cannot replay: a `type` a newer panel wrote, or a field missing. */
+    skipped: number;
+    source?: {
+        id?: string;
+        url?: string;
+    };
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Serializes the ops armed on one query into clipboard text. `reset` never reaches a recorder's list, so
+ * what comes out is exactly what a paste can put back.
+ */
+declare const serializeQueryDevtoolsOverrideTransfer: (entries: readonly QueryDevtoolsOverrideEntry[], source?: {
+    id?: string;
+    url?: string;
+}) => string;
+/**
+ * Reads clipboard text back into ops. A bare array of ops is accepted alongside the full envelope, so a
+ * set pasted out of a ticket and trimmed by hand still lands; an op whose `type` this build doesn't know
+ * is counted in `skipped` rather than failing the whole paste, so an older panel can take a newer one's
+ * set minus the parts it cannot replay.
+ */
+declare const parseQueryDevtoolsOverrideTransfer: (text: string) => QueryDevtoolsOverrideTransferParse;
+/**
+ * How many of `ops` would not resolve against `raw` - what a paste onto a differently-shaped query
+ * reports, so ops sitting on nothing say so instead of looking armed. Replays them the same way the
+ * pipeline will, since an earlier op can be what makes a later one's path exist.
+ */
+declare const countUnresolvedQueryDevtoolsOverrides: (ops: readonly OverrideOp[], raw: unknown) => number;
+/** Arms every op of a parsed set onto a query, on top of whatever it already has armed. */
+declare const armQueryDevtoolsOverrideTransfer: (recorder: QueryDevtoolsOverridesRecorder, ops: readonly OverrideOp[]) => void;
 
 /**
  * How many destroyed queries the registry keeps. A tombstone holds the last response body it captured,
@@ -6516,20 +6769,6 @@ declare const snapshotQueryDevtoolsHandle: (handle: unknown) => unknown;
  */
 declare const tombstoneOf: (entry: QueryDevtoolsEntry, destroyedAt: number) => QueryDevtoolsEntry;
 
-/**
- * Whether a devtools UI is on the page, which is what the floating pills follow. Kept apart from the
- * pills themselves so `@ethlete/query-devtools/toggle` can declare itself without pulling the pill
- * renderer into the bundle an application ships.
- */
-/**
- * Declares a devtools UI on the page, and takes the declaration back when it goes. The floating pills
- * paint only while one is mounted, so an application that renders no devtools trigger shows no pills
- * either.
- *
- * Part of the devtools contract. **Not part of the general public contract.**
- */
-declare const setQueryDevtoolsUiMounted: (isMounted: boolean) => void;
-
 type TransformedGqlQuery = {
     query: string;
     variables?: string | Record<string, unknown>;
@@ -7285,6 +7524,8 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
      * @internal
      */
     _canBeCached?: boolean);
+    /** The full URL of the request the underlying query is bound to, `null` before the first execution. */
+    get url(): string | null;
     get rawState(): V2QueryState<ResponseType<QueryArgsOf<TNewQuery>>>;
     /**
      * `abort()` resets the underlying query, so it holds no execution state - the shape of a query that has
@@ -8801,7 +9042,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "text" | "json" | "blob" | "arraybuffer" | undefined;
+        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -8811,7 +9052,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "text" | "json" | "blob" | "arraybuffer" | undefined;
+        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -9232,15 +9473,15 @@ declare class QueryDirective<Q extends QueryDirectiveType | null> {
 /**
  * @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 invalidBaseRouteError: (data: unknown) => RuntimeError<1>;
+declare const invalidBaseRouteError: (base: unknown) => RuntimeError<10>;
 /**
  * @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 invalidRouteError: (data: unknown) => RuntimeError<2>;
+declare const invalidRouteError: (route: unknown) => RuntimeError<11>;
 /**
  * @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 pathParamsMissingInRouteFunctionError: (data: unknown) => RuntimeError<3>;
+declare const pathParamsMissingInRouteFunctionError: (route: unknown) => RuntimeError<12>;
 /**
  * @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.
  */
@@ -9444,7 +9685,7 @@ type QueryFormChange<TFields extends QueryFormFields> = {
  * Options passed to `observe()`. Named distinctly from the legacy
  * `QueryFormObserveOptions` to keep both APIs' barrel exports intact.
  */
-type QueryFormSignalsObserveOptions = {
+type QueryFormSignalsObserveOptions<TKey extends string = string> = {
     /**
      * Sync the committed value to the URL query params.
      * @default true
@@ -9464,7 +9705,7 @@ type QueryFormSignalsObserveOptions = {
      * Keep the committed value in a storage and restore it when the URL carries none of the persisted fields.
      * Off unless set.
      */
-    readonly persistence?: QueryFormPersistence;
+    readonly persistence?: QueryFormPersistence<TKey>;
 };
 /**
  * The storage a query form persists into. `sessionStorage` and `localStorage` satisfy it. Both methods are
@@ -9475,7 +9716,7 @@ type QueryFormStorage = {
     setItem(key: string, value: string): void;
 };
 /** Where and what a query form persists - the `persistence` option of `observe()`. */
-type QueryFormPersistence = {
+type QueryFormPersistence<TKey extends string = string> = {
     /** The storage key. Scope it per list, e.g. `'players-list'`. */
     readonly key: string;
     /**
@@ -9484,7 +9725,7 @@ type QueryFormPersistence = {
      */
     readonly storage: 'session' | 'local' | QueryFormStorage;
     /** The fields to persist and to check the URL for. Defaults to every field. */
-    readonly fields?: readonly string[];
+    readonly fields?: readonly TKey[];
 };
 /**
  * Options for a single programmatic write (`setValue`/`patchValue`/reset).
@@ -9577,7 +9818,7 @@ type QueryFormSignals<TFields extends QueryFormFields> = {
     /** The default value of the whole form. */
     readonly defaultValue: QueryFormModel<TFields>;
     /** Start syncing with the URL. Returns the form, so it can be chained onto the definition. */
-    observe(options?: QueryFormSignalsObserveOptions): QueryFormSignals<TFields>;
+    observe(options?: QueryFormSignalsObserveOptions<keyof TFields & string>): QueryFormSignals<TFields>;
     /**
      * Stop syncing and strip the form's params from the URL. A pending debounced edit is committed to `value`
      * but not written to the URL. Only an explicit call strips the params - the
@@ -9668,7 +9909,8 @@ 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.
+ * A single date field. By default it holds a `Date`, written to the URL as an ISO string and read back from
+ * any `Date`-parseable one.
  * `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.
  *
@@ -9769,14 +10011,29 @@ type CreateWebSocketClientConfigOptions = {
     withCredentials?: boolean;
     /**
      * The handshake payload, sent on every connect and reconnect. Pass a function to read a fresh value
-     * (e.g. the current access token) each time.
+     * each time; it runs outside an injection context, so it cannot call `injectAuthProvider()`. For a
+     * bearer auth provider use {@link authProvider} instead. Setting both is a dev-mode error and
+     * `authProvider` wins.
      *
      * @example
      * ```ts
-     * createWebSocketClient({ name: 'match', url, io, auth: () => ({ token: auth.accessToken() }) });
+     * createWebSocketClient({ name: 'match', url, io, auth: () => ({ token: readCookieToken() }) });
      * ```
      */
     auth?: WebSocketClientAuth | (() => WebSocketClientAuth);
+    /**
+     * A bearer auth provider whose session the socket follows. The handshake carries
+     * `{ token: accessToken() }`. The socket does not connect while the session is `'unknown'` or
+     * `'restoring'`, reconnects when a session starts (a login, or a different user), and disconnects and
+     * completes its rooms on logout. A token rotation within a session does not reconnect; the next
+     * reconnect reads the fresh token.
+     *
+     * @example
+     * ```ts
+     * createWebSocketClient({ name: 'match', url, io, authProvider: myAuthProviderRef });
+     * ```
+     */
+    authProvider?: AnyCreateBearerAuthProviderResult;
 };
 /** A default socket io message view */
 type SocketMessageView<TMessageData = unknown> = {
@@ -9831,7 +10088,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.54";
+declare const QUERY_VERSION = "6.0.0-next.55";
 
-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 };
+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, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, IS_QUERY_REQUEST, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, 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, applyQueryFeatures, authAccessTokenExpiryUnreadable, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsTokenTtl, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, 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, createQueryErrorResponse, createQueryFeature, createQueryGroup, 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, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, executeUntilSettled$, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, invalidatesUsedOnRead, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryCreatedInReactiveContext, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryExecutedWhileParkedMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, recordExecutionArgs, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryHeaders, searchQueryField, serializeBody, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, skipParkedExecution, sortQueryField, splitQueryConfig, stringArrayQueryField, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, tableSortQueryField, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, 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, withOptimisticUpdate, withOptimisticUpdateUsedOnRead, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, EMPTY_QUERY_DEVTOOLS_FAULT as ɵEMPTY_QUERY_DEVTOOLS_FAULT, MAX_QUERY_BATCH_TOMBSTONES as ɵMAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_BATCH_TOMBSTONE_BUCKETS as ɵMAX_QUERY_BATCH_TOMBSTONE_BUCKETS, MAX_QUERY_DEVTOOLS_TOMBSTONES as ɵMAX_QUERY_DEVTOOLS_TOMBSTONES, QUERY_DEVTOOLS_FAULT_STATUSES as ɵQUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT as ɵQUERY_DEVTOOLS_TOKEN_TTL_LIMIT, addQueryDevtoolsAuthAccount as ɵaddQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides as ɵapplyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl as ɵapplyQueryDevtoolsTokenTtl, armAllQueryDevtoolsMocks as ɵarmAllQueryDevtoolsMocks, armQueryDevtoolsMock as ɵarmQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer as ɵarmQueryDevtoolsOverrideTransfer, canOverrideQueryDevtoolsTokenTtl as ɵcanOverrideQueryDevtoolsTokenTtl, clearQueryDevtoolsArmedMocks as ɵclearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials as ɵclearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions as ɵclearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults as ɵclearQueryDevtoolsFaults, clearQueryDevtoolsMockStore as ɵclearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore as ɵclearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore as ɵclearQueryDevtoolsStore, clearQueryDevtoolsTombstones as ɵclearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides as ɵclearRestoredQueryDevtoolsOverrides, collectLeafPaths as ɵcollectLeafPaths, collectQueryDevtoolsSchemaComponents as ɵcollectQueryDevtoolsSchemaComponents, countUnresolvedQueryDevtoolsOverrides as ɵcountUnresolvedQueryDevtoolsOverrides, createQueryDevtoolsOverrides as ɵcreateQueryDevtoolsOverrides, deleteQueryDevtoolsMock as ɵdeleteQueryDevtoolsMock, detectPaginationShape as ɵdetectPaginationShape, forgetQueryDevtoolsAuthSession as ɵforgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor as ɵforgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset as ɵgenerateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber as ɵgenerateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset as ɵgenerateQueryDevtoolsStringPreset, hasQueryDevtoolsOverridesAtPath as ɵhasQueryDevtoolsOverridesAtPath, isDateShapedLeaf as ɵisDateShapedLeaf, isQueryDevtoolsEnabled as ɵisQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed as ɵisQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive as ɵisQueryDevtoolsRepositoryLive, loadQueryDevtoolsSchema as ɵloadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount as ɵloginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession as ɵlogoutQueryDevtoolsAuthSession, matchesQueryDevtoolsMockPattern as ɵmatchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery as ɵmatchesQueryDevtoolsMockQuery, measureQueryDevtoolsPayload as ɵmeasureQueryDevtoolsPayload, parseQueryDevtoolsOverrideTransfer as ɵparseQueryDevtoolsOverrideTransfer, queryDevtoolsAbout as ɵqueryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions as ɵqueryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds as ɵqueryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction as ɵqueryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope as ɵqueryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues as ɵqueryDevtoolsApiEnvValues, queryDevtoolsApiEnvs as ɵqueryDevtoolsApiEnvs, queryDevtoolsArmedMocks as ɵqueryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored as ɵqueryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor as ɵqueryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive as ɵqueryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor as ɵqueryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount as ɵqueryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions as ɵqueryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor as ɵqueryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal as ɵqueryDevtoolsAuthTabLocal, queryDevtoolsEntries as ɵqueryDevtoolsEntries, queryDevtoolsFaults as ɵqueryDevtoolsFaults, queryDevtoolsFaultsRestored as ɵqueryDevtoolsFaultsRestored, queryDevtoolsMockId as ɵqueryDevtoolsMockId, queryDevtoolsMocks as ɵqueryDevtoolsMocks, queryDevtoolsOverridePersistence as ɵqueryDevtoolsOverridePersistence, queryDevtoolsRequestPath as ɵqueryDevtoolsRequestPath, queryDevtoolsResponseHistory as ɵqueryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope as ɵqueryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames as ɵqueryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes as ɵqueryDevtoolsSchemaRoutes, queryDevtoolsSchemaState as ɵqueryDevtoolsSchemaState, queryDevtoolsSettings as ɵqueryDevtoolsSettings, queryDevtoolsStorage as ɵqueryDevtoolsStorage, queryDevtoolsTokenTtls as ɵqueryDevtoolsTokenTtls, readQueryDevtoolsStore as ɵreadQueryDevtoolsStore, registerEthleteVersion as ɵregisterEthleteVersion, removeQueryDevtoolsAuthAccount as ɵremoveQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession as ɵrenameQueryDevtoolsAuthSession, restoredQueryDevtoolsOverrides as ɵrestoredQueryDevtoolsOverrides, saveQueryDevtoolsMock as ɵsaveQueryDevtoolsMock, seedQueryDevtoolsSchemaBody as ɵseedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute as ɵseedQueryDevtoolsSchemaRoute, serializeQueryDevtoolsOverrideTransfer as ɵserializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv as ɵsetQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo as ɵsetQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope as ɵsetQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials as ɵsetQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal as ɵsetQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault as ɵsetQueryDevtoolsFault, setQueryDevtoolsFaultsScope as ɵsetQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence as ɵsetQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope as ɵsetQueryDevtoolsOverridesScope, setQueryDevtoolsSettings as ɵsetQueryDevtoolsSettings, smartDuplicateArrayItem as ɵsmartDuplicateArrayItem, snapshotQueryDevtoolsHandle as ɵsnapshotQueryDevtoolsHandle, stringifyQueryRouteParts as ɵstringifyQueryRouteParts, sumQueryDevtoolsStats as ɵsumQueryDevtoolsStats, switchQueryDevtoolsAuthSession as ɵswitchQueryDevtoolsAuthSession, tombstoneOf as ɵtombstoneOf, writeQueryDevtoolsStore as ɵwriteQueryDevtoolsStore };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQueryGroup, 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, 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, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptimisticUpdateContext, OptionalQueryFieldOptions, 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, QueryBeforeExecuteFn, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryCreator, QueryCreatorInput, QueryDataOf, QueryDependencies, QueryDevtoolsApiEnv, QueryDevtoolsApiEnvSwitch, QueryDevtoolsAppInfo, QueryDevtoolsAuthAccount, QueryDevtoolsAuthField, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsOptions, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, 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, QueryGroup, QueryGroupLatest, QueryGroupMembers, QueryGroupSuccess, QueryHeaders, QueryHeadersInput, QueryInvalidatesContext, QueryInvalidatesOption, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryInvalidationTarget, QueryInvalidationUrl, 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, QueryTagsContext, QueryTagsOption, 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, 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, WithOptimisticUpdateOptions, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables, DescribableFeature as ɵDescribableFeature, JsonPath as ɵJsonPath, OverrideOp as ɵOverrideOp, QueryDevtoolsAbout as ɵQueryDevtoolsAbout, QueryDevtoolsAuthAccountView as ɵQueryDevtoolsAuthAccountView, QueryDevtoolsAuthLocalAccount as ɵQueryDevtoolsAuthLocalAccount, QueryDevtoolsAuthProviderHandle as ɵQueryDevtoolsAuthProviderHandle, QueryDevtoolsAuthProviderRegistration as ɵQueryDevtoolsAuthProviderRegistration, QueryDevtoolsAuthQuery as ɵQueryDevtoolsAuthQuery, QueryDevtoolsAuthSeed as ɵQueryDevtoolsAuthSeed, QueryDevtoolsAuthSession as ɵQueryDevtoolsAuthSession, QueryDevtoolsEntry as ɵQueryDevtoolsEntry, QueryDevtoolsEntryKind as ɵQueryDevtoolsEntryKind, QueryDevtoolsEntryMeta as ɵQueryDevtoolsEntryMeta, QueryDevtoolsFault as ɵQueryDevtoolsFault, QueryDevtoolsFaultTarget as ɵQueryDevtoolsFaultTarget, QueryDevtoolsFeature as ɵQueryDevtoolsFeature, QueryDevtoolsFormField as ɵQueryDevtoolsFormField, QueryDevtoolsFormHandle as ɵQueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle as ɵQueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder as ɵQueryDevtoolsFormLinksRecorder, QueryDevtoolsMock as ɵQueryDevtoolsMock, QueryDevtoolsMockTarget as ɵQueryDevtoolsMockTarget, QueryDevtoolsOverrideEntry as ɵQueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer as ɵQueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse as ɵQueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle as ɵQueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder as ɵQueryDevtoolsOverridesRecorder, QueryDevtoolsPayload as ɵQueryDevtoolsPayload, QueryDevtoolsRegistrar as ɵQueryDevtoolsRegistrar, QueryDevtoolsRegistration as ɵQueryDevtoolsRegistration, QueryDevtoolsResolvedFault as ɵQueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock as ɵQueryDevtoolsResolvedMock, QueryDevtoolsRoutePart as ɵQueryDevtoolsRoutePart, QueryDevtoolsRun as ɵQueryDevtoolsRun, QueryDevtoolsRunError as ɵQueryDevtoolsRunError, QueryDevtoolsRunStatus as ɵQueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents as ɵQueryDevtoolsSchemaComponents, QueryDevtoolsSchemaRoute as ɵQueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed as ɵQueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState as ɵQueryDevtoolsSchemaState, QueryDevtoolsSeedStyle as ɵQueryDevtoolsSeedStyle, QueryDevtoolsSettings as ɵQueryDevtoolsSettings, QueryDevtoolsStats as ɵQueryDevtoolsStats, QueryDevtoolsStatsHandle as ɵQueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder as ɵQueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope as ɵQueryDevtoolsStorageScope, RestoredQueryDevtoolsOverrides as ɵRestoredQueryDevtoolsOverrides };