@ethlete/query 6.0.0-next.33 → 6.0.0-next.35

package/types/ethlete-query.d.ts

@@ -151,6 +151,56 @@ type ShouldRetryRequestResult = {
     delay: number;
 };
 type ShouldRetryRequestFn = (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
+/** @see createDefaultRetryFn */
+type DefaultRetryOptions = {
+    /**
+     * How many times a failed request is retried before its error is handed to the caller.
+     *
+     * `0` retries indefinitely, which is only ever right for a request nothing renders: a query that
+     * never stops retrying never resolves to an error, so it stays `loading()` for as long as the
+     * server stays down and the UI has nothing to show but a spinner.
+     *
+     * @default 3
+     */
+    maxAttempts?: number;
+    /** The delay doubles per retry, starting at twice this. @default 1000 */
+    baseDelayMs?: number;
+    /** Upper bound of every delay, including one a `retry-after` header asked for. @default 30000 */
+    maxDelayMs?: number;
+    /**
+     * How far the delay is spread randomly around its computed value, as a fraction of it: `0.25` picks
+     * a delay between 0.75x and 1.25x. Keeps the tabs that failed together from retrying together.
+     * `0` makes the backoff exact. A delay a `retry-after` header named is never jittered.
+     *
+     * @default 0.25
+     */
+    jitter?: number;
+    /**
+     * Which response statuses are worth retrying, replacing the defaults rather than adding to them.
+     * A connection failure is status `0`.
+     *
+     * @default a connection failure (`0`), `408`, `425`, `429`, and every 5xx above `500`
+     */
+    retryableStatusCodes?: number[];
+};
+/**
+ * Builds a retry policy: an exponentially backing off, jittered {@link ShouldRetryRequestFn} bounded by
+ * an attempt ceiling. What {@link withDefaultRetry} installs - reach for this directly to hand a single
+ * client or creator its own `retryFn`.
+ *
+ * @example
+ * const flakyEndpointRetry = createDefaultRetryFn({ maxAttempts: 8, maxDelayMs: 10_000 });
+ *
+ * const getReport = myApiGet<GetReportArgs>('/report').clone({ retryFn: flakyEndpointRetry });
+ */
+declare const createDefaultRetryFn: (options?: DefaultRetryOptions) => ShouldRetryRequestFn;
+/**
+ * The SDK's default retry policy, installed by {@link withDefaultRetry}: three retries with an
+ * exponentially backing off, jittered delay, for a connection failure, a `408`, a `425`, a `429`
+ * (honouring `retry-after`) and a 5xx above `500`.
+ *
+ * Pass {@link createDefaultRetryFn} options to {@link withDefaultRetry} to configure it.
+ */
 declare const shouldRetryRequest: (options: ShouldRetryRequestOptions | HttpErrorResponse) => ShouldRetryRequestResult;
 
 type QueryErrorResponseList = {
@@ -205,6 +255,11 @@ declare const setupQueryExecuteState: () => QueryExecuteState;
 type RunQueryExecuteOptions = {
     allowCache?: boolean;
     triggeredBy?: string;
+    /**
+     * Overrides the creator's (and the client's) `keepUnusedFor` for this execution. Only read while the
+     * cache entry is being created: an entry that already exists keeps the retention it was created with.
+     */
+    keepUnusedFor?: number;
 };
 type QueryExecuteOptions<TArgs extends QueryArgs> = {
     executeOptions: CreateQueryExecuteOptions<TArgs>;
@@ -985,16 +1040,11 @@ type InternalQueryExecute<TArgs extends QueryArgs> = {
 type QueryExecute<TArgs extends QueryArgs> = (executeArgs?: QueryExecuteArgs<TArgs>) => void;
 declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;
 
-/**
- * Returning this inside a withArgs feature will reset the query args to null.
- * This will also pause polling and auto refresh until new args are set.
- */
-declare const CLEAR_QUERY_ARGS: unique symbol;
-type ClearQueryArgs = typeof CLEAR_QUERY_ARGS;
 /** A angular effect that can be nested inside another effect */
 declare const nestedEffect: (fn: () => void, options?: CreateEffectOptions) => _angular_core.EffectRef;
 type QueryFeatureFlags = {
     hasWithArgsFeature: boolean;
+    hasPollingFeature: boolean;
     shouldAutoExecuteMethod: boolean;
     shouldAutoExecute: boolean;
     hasRouteFunction: boolean;
@@ -1010,6 +1060,7 @@ declare const QueryFeatureType: {
     readonly WITH_ERROR_HANDLING: "WITH_ERROR_HANDLING";
     readonly WITH_SUCCESS_HANDLING: "WITH_SUCCESS_HANDLING";
     readonly WITH_POLLING: "WITH_POLLING";
+    readonly WITH_LONG_POLLING: "WITH_LONG_POLLING";
     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";
@@ -1037,12 +1088,12 @@ declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
  * A query feature that allows you to set the arguments of the query.
  * The arguments are read within a computed function, so you can use reactive values.
  *
- * To set the arguments to `null`, return the symbol `CLEAR_QUERY_ARGS`.
- * If you instead return `null`, the arguments won't change.
+ * Return `null` to park the query: its args are reset to `null`, and polling and auto refresh
+ * pause until args are set again.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
-declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | ClearQueryArgs | null) => QueryFeature<TArgs>;
+declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | null) => QueryFeature<TArgs>;
 type WithPollingFeatureOptions = {
     /** The interval in milliseconds at which the query should be executed */
     interval: number;
@@ -1067,6 +1118,60 @@ type WithPollingFeatureOptions = {
  * @throws If the query is not eligible for auto execution (e.g. a POST request)
  */
 declare const withPolling: <TArgs extends QueryArgs>(options: WithPollingFeatureOptions) => QueryFeature<TArgs>;
+type WithLongPollingFeatureOptions<TArgs extends QueryArgs> = {
+    /**
+     * Derives the next round's args from the round that just settled - typically a cursor read off the
+     * response. `response` is `null` when the server answered without a body (a `204` on timeout).
+     * Return `null` to end the chain; only a new `withArgs` value or a manual `execute()` starts it again.
+     */
+    nextArgs: (response: ResponseType<TArgs> | null, args: RequestArgs<TArgs> | null) => NoInfer<RequestArgs<TArgs>> | null;
+    /**
+     * The pause between one round settling and the next starting, in milliseconds. A server that already
+     * has data answers a long poll immediately, so this is what keeps a busy feed from becoming a hot
+     * request loop.
+     * @default 250
+     */
+    delay?: number;
+    /**
+     * How long to wait before repeating a round that failed, in milliseconds. Doubles with every
+     * consecutive failure up to {@link WithLongPollingFeatureOptions.maxErrorDelay}, and resets on the
+     * next success.
+     * @default 1000
+     */
+    errorDelay?: number;
+    /** The ceiling for the doubling `errorDelay`, in milliseconds. @default 30000 */
+    maxErrorDelay?: number;
+    /**
+     * How many consecutive failures end the chain. The query keeps its error, and only a new `withArgs`
+     * value or a manual `execute()` starts it again.
+     * @default 10
+     */
+    stopAfterErrors?: number;
+};
+/**
+ * A query feature for long polling: a chain of requests where each round starts once the previous one
+ * settled, with args derived from what it returned. Unlike {@link withPolling} there is no interval -
+ * the server decides the cadence by holding each request open until it has something to say.
+ *
+ * A failed round is repeated after a growing delay, so a transient failure does not silently end the
+ * feed. A new value from the `withArgs` source cancels the pending round and starts over from it.
+ *
+ * Rounds do not share the cache: each one is requested with `keepUnusedFor: 0`, because a cursor is
+ * asked for once and never again. They are also not deduped across tabs - `withMultiTabSync` elects a
+ * poller per cache key, and a chain's key moves with every round.
+ *
+ * @example
+ * const events = getEvents(
+ *   withArgs(() => ({ queryParams: { cursor: null } })),
+ *   withLongPolling({
+ *     nextArgs: (response) => (response ? { queryParams: { cursor: response.cursor } } : null),
+ *   }),
+ * );
+ *
+ * @throws If the query is not eligible for auto execution (e.g. a POST request)
+ * @throws If the query also has a `withPolling` feature
+ */
+declare const withLongPolling: <TArgs extends QueryArgs>(options: WithLongPollingFeatureOptions<TArgs>) => QueryFeature<TArgs>;
 type WithLoggingFeatureOptions<TArgs extends QueryArgs> = {
     /** A function that will be called with the latest http event */
     logFn: (v: RequestHttpEvent<TArgs> | null) => void;
@@ -2011,10 +2116,9 @@ declare const withHtmlErrorParsing: () => QueryClientFeatureFn;
  */
 declare const withSymfonyErrors: () => QueryClientFeatureFn;
 /**
- * Installs the SDK's default retry policy for every request that does not bring its own `retryFn`:
- * retry a connection failure indefinitely, a 5xx above 500, a 408/425, and a 429 (honouring
- * `retry-after`), up to three times with a backing-off delay - and never a Pagerfanta out-of-range
- * page.
+ * Installs the SDK's default retry policy for every request that does not bring its own `retryFn`: a
+ * connection failure, a 5xx above 500, a 408/425 and a 429 (honouring `retry-after`) are retried three
+ * times with an exponentially backing off, jittered delay - and a Pagerfanta out-of-range page never is.
  *
  * Without it nothing is retried automatically and `error.retryState` always reads `{ retry: false }`.
  * A per-client or per-creator `retryFn` keeps working either way.
@@ -2023,10 +2127,10 @@ declare const withSymfonyErrors: () => QueryClientFeatureFn;
  * const MY_CLIENT = createQueryClient({
  *   name: 'my-api',
  *   baseUrl: 'https://api.example.com',
- *   features: [withDefaultRetry()],
+ *   features: [withDefaultRetry({ maxAttempts: 5 })],
  * });
  */
-declare const withDefaultRetry: () => QueryClientFeatureFn;
+declare const withDefaultRetry: (options?: DefaultRetryOptions) => QueryClientFeatureFn;
 /**
  * Everything the error pipeline used to do before it became opt-in: {@link withHtmlErrorParsing},
  * {@link withSymfonyErrors} and {@link withDefaultRetry} in one feature. The soft landing for an app
@@ -2042,7 +2146,9 @@ declare const withDefaultRetry: () => QueryClientFeatureFn;
  *   features: [withEthleteApiErrors()],
  * });
  */
-declare const withEthleteApiErrors: () => QueryClientFeatureFn;
+declare const withEthleteApiErrors: (options?: {
+    retry?: DefaultRetryOptions;
+}) => QueryClientFeatureFn;
 
 type CacheAdapterFn = (headers: HttpHeaders) => number | null;
 type CreateQueryClientConfigOptions = {
@@ -2369,6 +2475,12 @@ type HttpRequestSubtle<TArgs extends QueryArgs> = {
      * access token to be available.
      */
     resolveHeaders: () => HttpHeaders | undefined;
+    /**
+     * The headers the most recent execution actually went out with. Unlike {@link resolveHeaders} it
+     * does not re-resolve the header providers, so after a token refresh it still reports the token
+     * the request was sent with. `undefined` until the first execution.
+     */
+    lastSentHeaders: () => HttpHeaders | undefined;
     /**
      * How many HTTP attempts the current execution has made, counting from 1. Anything above that is the
      * retry policy having fired. Reset by the next execution, so it keeps reading `3` after a request
@@ -2384,6 +2496,15 @@ type HttpRequestSubtle<TArgs extends QueryArgs> = {
      * this request spent any time on.
      */
     lastDurationMs: Signal<number | null>;
+    /**
+     * Cancels what the request currently has in flight - including a retry it is waiting out - without
+     * tearing it down: the response, error and freshness window it already holds are kept, and a later
+     * {@link HttpRequest.execute} runs as usual. Returns whether anything was in flight.
+     *
+     * What an entry retained without consumers does, so a revalidation nobody is waiting for stops
+     * instead of retrying into an empty room.
+     */
+    abort: () => boolean;
 };
 type HttpRequest<TArgs extends QueryArgs> = {
     /** The HTTP method of the request. */
@@ -2991,6 +3112,8 @@ declare const QueryRuntimeErrorCode: {
     readonly WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102;
     readonly WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY: 103;
     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 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;
@@ -3021,6 +3144,8 @@ declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<
 declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<101>;
 declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<102>;
 declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<103>;
+declare const withLongPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<105>;
+declare const withLongPollingUsedWithPolling: () => RuntimeError<106>;
 declare const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent: () => RuntimeError<104>;
 declare const authExtractTokensResponseNotObject: () => RuntimeError<200>;
 declare const authExtractTokensResponseMissingAccessToken: () => RuntimeError<201>;
@@ -3526,9 +3651,12 @@ type TokenRefreshQueryConfig<TArgs extends QueryArgs> = AuthQueryConfig<TArgs> &
      * Minimum interval between the *proactive* refreshes the expiry timer schedules, in milliseconds.
      * Prevents rapid refresh loops in case of issues.
      *
-     * A refresh a 401 asked for is never throttled by this - a token revoked seconds after a proactive
-     * refresh is exactly when the request must go out. Those are deduplicated instead: one refresh is
-     * in flight at a time.
+     * A refresh a 401 asked for is not throttled by this - a token revoked seconds after a proactive
+     * refresh is exactly when the request must go out. Those are kept in check differently: one
+     * refresh is in flight at a time, a 401 from a request that went out with an older access token
+     * refreshes nothing (the refresh it is asking for already happened), and once a whole streak of
+     * them runs back to back - every fresh token 401ing again, with no secure request succeeding in
+     * between - further ones fall back to this interval.
      *
      * @default 30000 (30 seconds)
      */
@@ -3639,7 +3767,8 @@ type InactivityLogoutFeature = {
      */
     disable: () => void;
     /**
-     * Reset the inactivity timer (mark user as active)
+     * Mark the user as active: postpones the logout and, with multi-tab sync on, postpones it in the
+     * session's other tabs too.
      */
     resetTimer: () => void;
     /**
@@ -3651,6 +3780,23 @@ type InactivityLogoutFeature = {
      */
     calculateTimeUntilLogout: () => number | null;
 };
+/**
+ * Ends the session once the user has been inactive for {@link InactivityLogoutConfig.inactivityTimeout},
+ * with `sessionEndCause` reporting `'inactivity'`.
+ *
+ * Idleness is a property of the session, not of a tab: with `withBearerAuthMultiTabSync` on, tabs tell
+ * each other about activity, so the tab the user is typing in keeps the forgotten one from logging
+ * everybody out. Without it - or with `syncLogout: false`, where a logout stays in the tab that
+ * decided it - each tab times out on its own.
+ *
+ * @example
+ * export const AUTH_PROVIDER = createBearerAuthProvider({
+ *   name: 'my-auth',
+ *   queryClientRef: MY_CLIENT,
+ *   queries: [loginQuery, refreshQuery],
+ *   features: [withBearerAuthMultiTabSync(), withInactivityLogout({ inactivityTimeout: 5 * 60 * 1000 })],
+ * });
+ */
 declare const withInactivityLogout: <TBuilders extends readonly AnyQueryBuilder[]>(config?: InactivityLogoutConfig) => (context: BearerAuthProviderFeatureContext<unknown, TBuilders>) => {
     type: "INACTIVITY_LOGOUT";
     instance: InactivityLogoutFeature;
@@ -3977,6 +4123,17 @@ declare const withTracking: <TBuilders extends readonly AnyQueryBuilder[]>(confi
 };
 declare const createTrackingFeature: <TBuilders extends readonly AnyQueryBuilder[]>(context: BearerAuthProviderFeatureContext<unknown, TBuilders>, config?: TrackingConfig<TBuilders>) => TrackingFeature<TBuilders>;
 
+/**
+ * The join handshake, from the joining tab's side: it asked for the session and is holding anything
+ * that would start a competing one until the answer arrives, or the wait runs out.
+ */
+type BearerAuthSessionAdoption = {
+    /** Whether the answer is still outstanding. `false` once tokens arrived, or the wait elapsed. */
+    isPending: () => boolean;
+    /** Resolves when tokens arrived or the wait elapsed - never rejects, and never waits forever. */
+    settled: Promise<void>;
+};
+
 type BearerAuthExecutionStateLoading<TType extends string = string> = {
     type: TType;
     state: 'loading';
@@ -4074,6 +4231,16 @@ type BearerAuthRefreshCoordination = {
     /** Emits in the leader tab whenever another tab asked for a refresh. */
     requests$: Observable<void>;
 };
+/**
+ * How the tabs of one session keep a single idea of when the user was last active. Contributed by
+ * `withBearerAuthMultiTabSync`; absent when a tab's idleness is nobody else's business.
+ */
+type BearerAuthActivityCoordination = {
+    /** Tells the other tabs the user did something here. */
+    announce: () => void;
+    /** Emits whenever another tab announced activity. Never echoes this tab's own. */
+    activity$: Observable<void>;
+};
 /** The parts of the provider an early setup can contribute. */
 type BearerAuthProviderEarlySetupResult = {
     isLeader?: () => boolean;
@@ -4082,6 +4249,8 @@ type BearerAuthProviderEarlySetupResult = {
         instanceCount: Signal<number>;
     };
     refreshCoordination?: BearerAuthRefreshCoordination;
+    sessionAdoption?: BearerAuthSessionAdoption;
+    activityCoordination?: BearerAuthActivityCoordination;
 };
 /**
  * A feature builder that additionally runs before the auth queries are set up. The auth queries read
@@ -4245,12 +4414,27 @@ type BearerAuthProviderFeatureContext<TBearerData = unknown, TBuilders extends r
         isLeader: Signal<boolean>;
         instanceCount: Signal<number>;
     };
+    /**
+     * The join handshake a tab runs at startup when multi-tab sync is on: it asked the leader for the
+     * live session, and `withPersistentAuth` holds its cookie auto-login until the answer arrives, so a
+     * second tab adopts the session instead of spending a refresh token on one of its own. Absent when
+     * there is nothing to adopt - no sync, no `BroadcastChannel`, or tokens deliberately tab-local.
+     */
+    sessionAdoption?: BearerAuthSessionAdoption;
+    /**
+     * How the tabs of this session share when the user was last active, so a feature that ends the
+     * session on idleness ends it on the _session_ being idle rather than on this tab being idle.
+     * Absent when no other tab is listening - no sync, no `BroadcastChannel`, or a tab-local logout.
+     */
+    activityCoordination?: BearerAuthActivityCoordination;
     queries: QueryRegistry<TBuilders>;
     executionState: WritableSignal<BearerAuthExecutionState | null>;
     sessionStatus: Signal<BearerAuthSessionStatus>;
     sessionEndCause: Signal<BearerAuthSessionEndCause | null>;
 };
 type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[]> = {
+    /** The provider's own name, as `createBearerAuthProvider({ name })` was given it. */
+    name: string;
     accessToken: WritableSignal<string | null>;
     refreshToken: WritableSignal<string | null>;
     bearerDecryptFn: ((token: string) => TBearerData) | undefined;
@@ -4389,6 +4573,90 @@ declare const setQueryDevtoolsAppInfo: (info: QueryDevtoolsAppInfo | undefined)
  */
 declare const queryDevtoolsAbout: () => QueryDevtoolsAbout;
 
+/**
+ * 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.
+ */
+type QueryDevtoolsStorageScope = 'none' | 'session' | 'local';
+/**
+ * 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 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;
+    /** 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;
+};
+/**
+ * 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;
+/**
+ * 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,
@@ -4424,6 +4692,17 @@ declare const QUERY_DEVTOOLS_FAULT_STATUSES: {
  * 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;
 /**
@@ -4693,10 +4972,15 @@ type QueryDevtoolsMock = {
 /** 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. **Never persisted, at any scope**: an app that silently serves designed
- * data tomorrow morning is worse than losing which mocks were armed, so arming is per page load.
+ * 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.
@@ -4726,89 +5010,18 @@ declare const saveQueryDevtoolsMock: (mock: QueryDevtoolsMock) => void;
 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;
-/** Empties the designed library and disarms everything - the panel's "Reset devtools". */
-declare const clearQueryDevtoolsMockStore: () => 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.
- */
-type QueryDevtoolsStorageScope = 'none' | 'session' | 'local';
-/**
- * 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 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. Whether one is
-     * served is never persisted at any scope.
-     */
-    mocks: 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;
-};
-/**
- * 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.**
+ * 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 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;
-/**
- * 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;
+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 = {
@@ -4995,6 +5208,24 @@ declare const queryDevtoolsSchemaNames: Signal<readonly string[]>;
  * Part of the devtools contract. **Not part of the general public contract.**
  */
 declare const seedQueryDevtoolsSchemaBody: (name: string) => QueryDevtoolsSchemaSeed | null;
+/** Everything a set of named schemas needs to resolve on its own, lifted out of the description. */
+type QueryDevtoolsSchemaComponents = {
+    /**
+     * 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.
+     */
+    schemas: Record<string, unknown>;
+    /** Refs that could not be brought along, so an exported document says why it does not resolve. */
+    notes: readonly string[];
+};
+/**
+ * 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 collectQueryDevtoolsSchemaComponents: (names: readonly string[]) => QueryDevtoolsSchemaComponents;
 /**
  * Every route the description declares, as the designer offers them - including the ones no query has
  * ever called, which is the case a mock exists for.
@@ -5066,6 +5297,64 @@ type QueryDevtoolsOptions = {
  */
 declare const provideQueryDevtools: (options?: QueryDevtoolsOptions) => EnvironmentProviders;
 
+/**
+ * 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 QUERY_DEVTOOLS_TOKEN_TTL_LIMIT = 604800;
+/**
+ * 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 queryDevtoolsTokenTtls: Signal<Record<string, number>>;
+/**
+ * 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 canOverrideQueryDevtoolsTokenTtl: (options: {
+    payload: Record<string, unknown> | null;
+    expiresInPropertyName?: string;
+}) => boolean;
+/**
+ * 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 setQueryDevtoolsTokenTtl: (options: {
+    providerName: string;
+    seconds: number;
+}) => void;
+/**
+ * Puts one provider back on its token's real lifetime, or every provider when no name is given.
+ *
+ * @see setQueryDevtoolsTokenTtl
+ */
+declare const clearQueryDevtoolsTokenTtl: (providerName?: string) => void;
+/**
+ * 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 applyQueryDevtoolsTokenTtl: <T>(options: {
+    payload: T;
+    providerName: string;
+    expiresInPropertyName?: string;
+}) => T;
+
 /**
  * How many destroyed queries the registry keeps. A tombstone holds the last response body it captured,
  * so the list is capped for the same reason the repository caps its unused entries.
@@ -8162,7 +8451,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.33";
+declare const QUERY_VERSION = "6.0.0-next.35";
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, 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, applyQueryDevtoolsOverrides, applyQueryFeatures, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, 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, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsFault, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, AuthGuardTarget, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsAppInfo, QueryDevtoolsAuthQuery, 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, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_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, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, 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, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, 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, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, 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, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsAppInfo, QueryDevtoolsAuthQuery, 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, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };