@ethlete/query 6.0.0-next.32 → 6.0.0-next.34

package/types/ethlete-query.d.ts

@@ -552,6 +552,14 @@ type JsonPath = (string | number)[];
  * share one entry point. Resetting a container therefore undoes a "fill recursively" run, whose ops
  * sit on the leaves rather than on the container itself.
  *
+ * `pasteArrayItem` splices rather than writing at an index, and treats an absent `index` as "at the
+ * end": a refetch that returns a shorter array would leave an index-addressed write sitting past the
+ * end, turning the gap into `null`s.
+ *
+ * `deleteAt` removes whatever sits at `path` from its parent - a key from an object, or an element from
+ * an array by splicing it out, so the ones after it shift down rather than leaving a hole. It is the only
+ * op that can make a field *absent* rather than empty, which is a different thing to the code reading it.
+ *
  * On the preset ops, `custom` - when present - is the exact value replayed, and `preset` is only the
  * label it was generated under. Values are generated once at arm time and stored, never re-rolled
  * inside apply, so a refetch replays the same response instead of reshuffling it.
@@ -581,6 +589,14 @@ type OverrideOp = {
     type: 'duplicateArrayItem';
     path: JsonPath;
     index: number;
+} | {
+    type: 'pasteArrayItem';
+    path: JsonPath;
+    value: unknown;
+    index?: number;
+} | {
+    type: 'deleteAt';
+    path: JsonPath;
 } | {
     type: 'duplicateArray';
     path: JsonPath;
@@ -675,6 +691,17 @@ declare const applyQueryDevtoolsOverrides: (entries: readonly QueryDevtoolsOverr
     value: unknown;
     staleIds: string[];
 };
+/**
+ * Accumulates the response overrides armed on one query, for the devtools panel. Instrumentation only
+ * creates one while {@link provideQueryDevtools} is installed - like {@link createQueryDevtoolsStats},
+ * an app without devtools pays nothing for it.
+ *
+ * The panel also creates one that belongs to no query at all, to record the edits made to a mock's draft
+ * body: the ops are flattened with {@link applyQueryDevtoolsOverrides} and thrown away on save.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const createQueryDevtoolsOverrides: () => QueryDevtoolsOverridesRecorder;
 
 /**
  * What a query did over its lifetime, as the devtools panel accounts for it: how often it ran, how many
@@ -834,9 +861,9 @@ type QueryDevtoolsStatsRecorder = QueryDevtoolsStatsHandle & {
     }) => void;
 };
 /**
- * How many bodies each query retains - {@link QueryDevtoolsOptions.responseHistory}, or `5`. Only a run
- * that still holds one can be an end of a response diff, so the panel reads this to say why an older run
- * can no longer be picked.
+ * How many bodies each query retains: what the panel's Settings tab asks for, or
+ * {@link QueryDevtoolsOptions.responseHistory}, or `5`. Only a run that still holds one can be an end of
+ * a response diff, so the panel reads this to say why an older run can no longer be picked.
  *
  * Part of the devtools contract. **Not part of the general public contract.**
  */
@@ -2342,6 +2369,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
@@ -3430,9 +3463,12 @@ type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
      * re-firing a mutation on the next login would repeat it behind the user's back.
      */
     autoExecutes: boolean;
-    transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> | undefined, tokens: {
-        accessToken: string;
-    }, headers: HttpHeaders, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
+    /**
+     * Hands the execution over to the concrete query implementation. `executeArgs.args.headers` is a
+     * provider function, not resolved headers - it must be passed through to the repository as-is, or
+     * the request freezes the access token it was first built with.
+     */
+    transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> | undefined, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
 };
 declare const createSecureExecuteFactory: <TArgs extends QueryArgs>(options: SecureExecuteFactoryOptions<TArgs>) => InternalQueryExecute<TArgs>;
 
@@ -3496,9 +3532,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)
      */
@@ -3750,11 +3789,24 @@ type PersistentAuthConfig<TBuilders extends readonly AnyQueryBuilder[], TKey ext
             key: TKey;
         }>>>;
         /**
-         * An array of routes where the auto login via cookie should not be triggered.
+         * An array of routes where the auto login via cookie should not be triggered. Prefix-matched, so
+         * `'/reset-password'` also excludes `/reset-password-templates`; reach for `shouldAutoLogin` when
+         * that matters.
          *
          * @default []
          */
         excludeRoutes?: string[];
+        /**
+         * Decides per URL whether auto-login may run, for the policy prefix matching cannot express - an
+         * exact path, a parsed `UrlTree`, a query parameter. Receives the current route as the router
+         * reports it.
+         *
+         * Runs *in addition to* `excludeRoutes`: either one refusing is enough to skip auto-login, so
+         * adding a predicate can never re-enable a route the list excluded.
+         *
+         * @default undefined
+         */
+        shouldAutoLogin?: (url: string) => boolean;
     };
 };
 type PersistentAuthFeature = {
@@ -4018,6 +4070,8 @@ type BearerAuthProviderEarlySetupContext = {
     applyTokens: (access: string, refresh: string) => void;
     /** Ends the session, exactly as the provider's own `logout()` does. */
     logout: (cause?: BearerAuthSessionEndCause) => void;
+    /** Why the last session ended, as {@link BearerAuthProvider.sessionEndCause} reports it. */
+    sessionEndCause: Signal<BearerAuthSessionEndCause | null>;
 };
 /**
  * How a tab that is not the leader gets a refresh out of the tab that is. Contributed by
@@ -4206,6 +4260,8 @@ type BearerAuthProviderFeatureContext<TBearerData = unknown, TBuilders extends r
     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;
@@ -4316,6 +4372,118 @@ type AuthGuard = {
  */
 declare const createAuthGuard: (providerRef: AnyCreateBearerAuthProviderResult, config: AuthGuardConfig) => AuthGuard;
 
+/**
+ * Free-form build information about the application itself - version, commit SHA, environment name,
+ * anything else a bug report should carry. The SDK cannot derive any of it, so it is handed in via
+ * `provideQueryDevtools({ about })`.
+ */
+type QueryDevtoolsAppInfo = Record<string, string | number | boolean>;
+type QueryDevtoolsAbout = {
+    /** Loaded `@ethlete/*` packages by short name (`core`, `query`, `components`), each a real version. */
+    ethlete: Record<string, string>;
+    angular: string;
+    app: QueryDevtoolsAppInfo | null;
+};
+/**
+ * Records that an `@ethlete/*` package is loaded, and at which version. Each lib passes its own
+ * generated constant; a package that is never imported never reports one, which is what makes the
+ * list "what is actually loaded" rather than "what is declared as a peer dependency".
+ */
+declare const registerEthleteVersion: (name: string, version: string) => void;
+declare const setQueryDevtoolsAppInfo: (info: QueryDevtoolsAppInfo | undefined) => void;
+/**
+ * Everything the devtools know about what is running: the loaded `@ethlete/*` versions, the Angular
+ * version, and whatever the application handed to `provideQueryDevtools({ about })`.
+ *
+ * Also mirrored onto `window.ethlete` - the same idea as Angular's `window.ng`, so the versions behind
+ * a bug report can be read straight from the console without opening the panel.
+ */
+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,
@@ -4351,6 +4519,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;
 /**
@@ -4574,6 +4753,324 @@ type QueryDevtoolsResolvedFault = {
     /** The status to fail the attempt with instead of sending it, or `null` to let it through. */
     status: number | null;
 };
+/** What a mock resolver matches against - the same three things a fault resolver sees. */
+type QueryDevtoolsMockTarget = QueryDevtoolsFaultTarget;
+/** The response the devtools want served instead of one upcoming attempt. */
+type QueryDevtoolsResolvedMock = {
+    /** The status to respond with. `400` and above are delivered as an `HttpErrorResponse`. */
+    status: number;
+    body: unknown;
+    /** How long to wait before the mocked response settles. */
+    latencyMs: number;
+};
+
+/**
+ * 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;
+    /**
+     * 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.
+     */
+    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[]>;
+/**
+ * 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, without its origin or query string - what a pattern is matched against. */
+declare const queryDevtoolsRequestPath: (url: string) => string;
+/**
+ * Whether a request carries every query parameter a mock declares. Extra parameters are ignored - a mock
+ * says what the request must ask for, not everything it may.
+ */
+declare const matchesQueryDevtoolsMockQuery: (declared: string, url: string) => boolean;
+/**
+ * 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 matchesQueryDevtoolsMockPattern: (pattern: string, path: string) => boolean;
+/**
+ * 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 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;
+/**
+ * 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 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;
+};
+/**
+ * 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 queryDevtoolsOverridePersistence: Signal<boolean>;
+/**
+ * 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 setQueryDevtoolsOverridesScope: (next: QueryDevtoolsStorageScope) => 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`).
+ */
+declare const setQueryDevtoolsOverridePersistence: (value: boolean) => void;
+/**
+ * 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 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.
+ */
+declare const restoredQueryDevtoolsOverrides: Signal<readonly RestoredQueryDevtoolsOverrides[]>;
+/**
+ * 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 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";
+/**
+ * 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.
+ */
+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;
+};
+/**
+ * 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 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`.
+ *
+ * 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()) })
+ * ```
+ */
+type QueryDevtoolsSchemaLoader = () => Promise<unknown> | unknown;
+/**
+ * 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`, 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;
+    /**
+     * 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.
+     */
+    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[];
+};
+/**
+ * Where the API description stands, for the panel's seeding controls.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsSchemaState: Signal<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: () => void;
+/**
+ * Every schema the 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: Signal<readonly string[]>;
+/**
+ * Generates a body from one named schema (`MatchView`), or `null` when the description does not name it.
+ *
+ * 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.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsSchemaRoutes: Signal<readonly QueryDevtoolsSchemaRoute[]>;
+/**
+ * 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 seedQueryDevtoolsSchemaRoute: (target: {
+    method: string;
+    pattern: string;
+}) => QueryDevtoolsSchemaSeed | null;
 
 /**
  * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
@@ -4591,8 +5088,24 @@ 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 application's OpenAPI (or JSON Schema) document, 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. The
+     * loader runs at most once, and only when the designer first asks for it - see
+     * {@link QueryDevtoolsSchemaLoader}.
+     */
+    schema?: QueryDevtoolsSchemaLoader;
 };
 /**
  * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
@@ -4611,6 +5124,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.
@@ -6870,7 +7441,7 @@ declare class QueryDevtoolsComponent {
                 readonly cookieExpiresInDays: number | "30 (default)";
                 readonly cookiePath: string;
                 readonly cookieEnabled: boolean | "true (default)";
-                readonly cookieSameSite: "strict" | "none" | "lax" | "lax (default)";
+                readonly cookieSameSite: "none" | "strict" | "lax" | "lax (default)";
                 readonly refreshBuffer: number | "30000 (default)";
                 readonly expiresInPropertyName: string;
                 readonly strategy: _ethlete_query.AuthBearerRefreshStrategy | "AuthBearerRefreshStrategy.BeforeExpiration (default)";
@@ -7706,5 +8277,8 @@ type WebSocketClientResult<TMessageData extends SocketMessageView = SocketMessag
 type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientResult<TMessageData>;
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, clearQueryDevtoolsTombstones, collectLeafPaths, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, 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, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsResponseHistory, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, 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, QueryDevtoolsAuthQuery, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+/** The version of `@ethlete/query` this build was cut from. */
+declare const QUERY_VERSION = "6.0.0-next.34";
+
+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_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, 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, 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, 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, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };