@ethlete/query 6.0.0-next.44 → 6.0.0-next.46

package/types/ethlete-query.d.ts

@@ -4,7 +4,7 @@ import { Observable, Subscribable, BehaviorSubject } from 'rxjs';
 import * as _angular_core from '@angular/core';
 import { DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, Signal, Injector, CreateEffectOptions, EnvironmentProviders, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
-import { RuntimeError, ProviderDefinition } from '@ethlete/core';
+import { ProviderDefinition, RuntimeError } from '@ethlete/core';
 import * as _angular_common_http from '@angular/common/http';
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpEvent, HttpStatusCode } from '@angular/common/http';
 import * as _ethlete_query from '@ethlete/query';
@@ -41,9 +41,6 @@ type DescribableFeature = {
     devtools?: QueryDevtoolsFeatureDescriber;
 };
 
-declare const invalidBaseRouteError: (data: unknown) => RuntimeError<1>;
-declare const invalidRouteError: (data: unknown) => RuntimeError<2>;
-declare const pathParamsMissingInRouteFunctionError: (data: unknown) => RuntimeError<3>;
 type QueryParams = object;
 type PathParams = Record<string, string | number>;
 /** A literal route, or a function building one from path params. Structurally the legacy `AnyRoute`. */
@@ -98,19 +95,6 @@ type BuildQueryStringConfig = {
      */
     ignoredValuesFns?: Array<(value: unknown) => boolean>;
 };
-declare const isNaN: (value: unknown) => boolean;
-declare const isEmptyString: (value: unknown) => boolean;
-declare const buildQueryString: (params: QueryParams, config?: BuildQueryStringConfig) => string | null;
-declare const buildRoute: (options: {
-    base: string;
-    route: RouteInput | null | undefined;
-    pathParams?: PathParams;
-    queryParams?: QueryParams;
-    queryParamConfig?: BuildQueryStringConfig;
-}) => string;
-declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
-/** Reads a bearer token's payload. */
-declare const decryptBearer: <Result = Record<string, unknown>>(token: string) => Result | null;
 
 type SetupQueryDependenciesOptions = {
     /** The query client tuple from createQueryClient */
@@ -134,7 +118,7 @@ type QueryDependencies = {
     /**
      * The DOM element of the component/directive that created the query, when it was created in an
      * element (node) injection context. `null` for queries created in a root/environment context.
-     * Used only by the devtools "inspect" tool.
+     * Used only by the devtools "inspect" tool, and resolved from the host injector on each read.
      */
     hostElement: HTMLElement | null;
 };
@@ -259,8 +243,9 @@ 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.
+     * Overrides the creator's (and the client's) `keepUnusedFor` for this execution. A cache entry shared
+     * by several queries keeps the shortest retention of the queries currently bound to it, so a query
+     * that asks for a shorter one only shortens the entry until it releases the entry again.
      */
     keepUnusedFor?: number;
 };
@@ -274,8 +259,13 @@ type QueryExecuteOptions<TArgs extends QueryArgs> = {
     isRefreshable?: boolean;
 };
 declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+/**
+ * Throws `ET800` once the same query runs with identical args more than five times in a row, each run
+ * less than 100 ms after the previous one. Executions with different args (a search term typed fast,
+ * a slider bound to `withArgs`) never count against each other.
+ */
 declare const circularQueryDependencyChecker: () => {
-    check: () => void;
+    check: (args: RequestArgs<QueryArgs> | null | undefined) => void;
 };
 
 /**
@@ -320,6 +310,8 @@ type QueryRepositoryEvent = {
     isCached: boolean;
     /** @see BaseQueryCreatorOptions.multiTabSync */
     isMultiTabSyncEnabled: boolean;
+    /** @see QueryRepositoryRequestOptions.isRefreshable */
+    isRefreshable: boolean;
     /**
      * Whether this response may be written to the client's persisted store. Already accounts for
      * secure requests needing an explicit opt-in.
@@ -581,10 +573,8 @@ type QueryDevtoolsFormLinksHandle = {
      * The devtools ids of the query forms this query's args have read. Empty for a query whose args read
      * none.
      *
-     * Accumulates rather than being rebuilt per evaluation: a form's `value` is a memoized signal, so an
-     * args build that re-runs for an unrelated reason reads the cached value without going through the
-     * form again. Dropping the id there would make the link flicker; a form that a conditional branch
-     * stops reading keeps its link until the query is recreated instead.
+     * Accumulates rather than being rebuilt per evaluation, so a form that a conditional branch stops
+     * reading keeps its link until the query is recreated instead of making the panel flicker.
      */
     ids: Signal<readonly string[]>;
 };
@@ -979,6 +969,14 @@ type QueryStateSubtle<TArgs extends QueryArgs> = {
      * Called by `queryExecute` whenever a request is (re-)executed.
      */
     bindRequestEvents: (request: HttpRequest<TArgs>) => void;
+    /** Stops forwarding the current request's events; `reset()` detaches the query from its request with it. */
+    unbindRequestEvents: () => void;
+    /**
+     * Run options every execution of this query starts from; the options passed to one `execute()` win
+     * per field. Set by a feature during creation so it also covers executions the feature does not
+     * trigger itself (`withLongPolling` turns retention off for the `withArgs` round too).
+     */
+    defaultRunOptions: WritableSignal<RunQueryExecuteOptions | null>;
     /**
      * Installs the reactive source that backs `state.args`. The `withArgs` feature uses this so that
      * `state.args` always reflects the latest args (pulled from the reactive source on read) instead
@@ -1095,13 +1093,14 @@ type QueryFeatureContext<TArgs extends QueryArgs> = {
 };
 type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;
 type QueryFeature<TArgs extends QueryArgs> = {
-    type: QueryFeatureType;
+    /** One of {@link QueryFeatureType} for the built-in features, or any name for a custom one. Used twice on one query, it throws. */
+    type: QueryFeatureType | (string & {});
     fn: (context: QueryFeatureContext<TArgs>) => void;
     /** How the feature was configured, for the devtools. Only called while devtools are enabled. */
     devtools?: QueryDevtoolsFeatureDescriber;
 };
 declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
-    type: QueryFeatureType;
+    type: QueryFeatureType | (string & {});
     fn: QueryFeatureFn<TArgs>;
     devtools?: QueryDevtoolsFeatureDescriber;
 }) => QueryFeature<TArgs>;
@@ -1621,6 +1620,13 @@ type PersistedQueryEntry = PersistedQueryEntryMeta & {
  */
 type PersistedQueryBody = {
     body: unknown;
+    /**
+     * The {@link PersistedQueryEntryMeta.version} the body was written under. Return it: two builds
+     * share one store, and without it the engine cannot tell a body another build wrote over this key
+     * from its own. A body whose version differs from the index is ignored; one without a version is
+     * trusted.
+     */
+    version?: number;
 };
 
 /**
@@ -1633,9 +1639,9 @@ type PersistedQueryBody = {
  * policy decision - how old a body may be, how many are kept, what happens on a logout - is made by
  * the persistence engine, so a custom adapter cannot get any of it subtly wrong.
  *
- * Every method may reject. The engine treats a failing read as a miss and a failing write as a full
- * disk (it prunes and retries once, then stops writing for the session), so an adapter never needs to
- * swallow its own errors.
+ * Every method may reject. The engine treats a failing read as a miss and retries a failing write once
+ * - after pruning the oldest half when it rejected with a `QuotaExceededError` - then stops writing for
+ * the session, so an adapter never needs to swallow its own errors.
  */
 type QueryPersistenceAdapter = {
     /**
@@ -1643,7 +1649,10 @@ type QueryPersistenceAdapter = {
      * at startup - the one bulk read there is.
      */
     loadIndex: () => Promise<PersistedQueryEntryMeta[]>;
-    /** Reads a single body back, or `null` when the store does not hold that key. */
+    /**
+     * Reads a single body back with the `version` it was written under, or `null` when the store does
+     * not hold that key.
+     */
     read: (key: QueryKey) => Promise<PersistedQueryBody | null>;
     /**
      * Writes entries, replacing any it already holds under the same key. Called with a batch, since the
@@ -1694,7 +1703,7 @@ type QueryPersistenceConfig = {
     storageName?: string;
     /**
      * The version of the *response shapes* this app persists. Every entry is written under it, and an
-     * entry written under a different one is dropped rather than hydrated.
+     * entry written under a different one is never hydrated, and only removed once older than `maxAge`.
      *
      * Bump it in the same commit that changes what a response looks like - a renamed field, a different
      * pagination envelope - so a returning user's disk copy cannot be handed to code that no longer
@@ -1783,6 +1792,11 @@ type QueryPersistenceEngine = {
     clear: () => Promise<void>;
     /** The metadata of everything the store holds, for the devtools. Bodies are not read. */
     indexEntries: () => PersistedQueryEntryMeta[];
+    /**
+     * Holds persisted responses of secure queries back while `false` and hydrates what it held once it
+     * turns `true`. Open by default; a bearer auth provider opens it only for an authenticated session.
+     */
+    setSecureHydrationOpen: (isOpen: boolean) => void;
     /** Stops listening, flushes one last time. */
     destroy: () => void;
 };
@@ -2064,13 +2078,15 @@ type QueryClientPersistenceFeature = {
     devtools?: QueryDevtoolsFeatureDescriber;
 };
 /**
- * A feature that only installs error-pipeline behavior. It has no per-client instance: how an error
- * body is read, and whether a failed request is retried, is a property of the app rather than of one
- * client.
+ * A feature that only installs error-pipeline behavior. Which body shapes are understood is a
+ * property of the app and is registered process-wide; the retry policy belongs to the client that
+ * asked for it and travels on `retryFn`.
  */
 type QueryClientErrorPipelineFeature = {
     type: typeof QueryClientFeatureType.HTML_ERROR_PARSING | typeof QueryClientFeatureType.SYMFONY_ERRORS | typeof QueryClientFeatureType.DEFAULT_RETRY | typeof QueryClientFeatureType.ETHLETE_API_ERRORS;
     instance: null;
+    /** The retry policy the client adopts unless it brings its own `retryFn`. */
+    retryFn?: ShouldRetryRequestFn;
 };
 type QueryClientFeature = QueryClientMultiTabSyncFeature | QueryClientPersistenceFeature | QueryClientErrorPipelineFeature;
 type QueryClientFeatureFn = (context: QueryClientFeatureContext) => QueryClientFeature;
@@ -2154,12 +2170,13 @@ 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`: a
+ * Gives this client 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.
+ * The policy belongs to the client the feature is on, so another client of the same app is not
+ * affected. Without it nothing is retried automatically and `error.retryState` always reads
+ * `{ retry: false }`. A per-client or per-creator `retryFn` wins over it.
  *
  * @example
  * const MY_CLIENT = createQueryClient({
@@ -2239,6 +2256,8 @@ type CreateQueryClientConfigOptions = {
      * The retry function to use for the client.
      * It determines if a request should be retried after it failed.
      *
+     * Wins over a {@link withDefaultRetry} feature on the same client.
+     *
      * @default the `withDefaultRetry()` policy, or no retry at all without that client feature
      */
     retryFn?: ShouldRetryRequestFn;
@@ -2271,8 +2290,9 @@ type CreateQueryClientConfigOptions = {
      * - {@link withDefaultRetry} retries connection failures, 5xx, 408/425 and 429,
      * - {@link withEthleteApiErrors} is the three error features above in one.
      *
-     * Each feature may be used at most once. The error-pipeline features are installed process-wide
-     * rather than per client - which body shapes an app understands is a property of the app.
+     * Each feature may be used at most once. The error **parsers** are installed process-wide rather
+     * than per client - which body shapes an app understands is a property of the app - while the retry
+     * policy stays on the client that asked for it.
      *
      * @example
      * const MY_CLIENT = createQueryClient({
@@ -2608,7 +2628,15 @@ type HttpErrorEvent = {
      */
     faulted?: boolean;
 };
-type RequestHttpEvent<TArgs extends QueryArgs> = HttpEvent<ResponseType<TArgs>> | HttpErrorEvent;
+/**
+ * A custom event marking an execution that was cancelled before it produced a response or an error -
+ * the entry was evicted, unbound by a logout, or retained without consumers. Terminal for that
+ * execution: everything the request already held is kept and a later `execute()` runs as usual.
+ */
+type HttpCancelEvent = {
+    type: 'cancel';
+};
+type RequestHttpEvent<TArgs extends QueryArgs> = HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | HttpCancelEvent;
 declare const createHttpRequest: <TArgs extends QueryArgs>(options: CreateHttpRequestOptions<TArgs>) => HttpRequest<TArgs>;
 
 type ObservableSignal<T> = Signal<T> & {
@@ -2740,13 +2768,22 @@ type BaseQueryCreatorFactoryOptions<TArgs extends QueryArgs, TOptions, TInternal
 };
 declare const createBaseQueryCreator: <TArgs extends QueryArgs, TOptions, TInternals>(config: BaseQueryCreatorFactoryOptions<TArgs, TOptions, TInternals>) => QueryCreator<TArgs>;
 
+/**
+ * The envelope a GraphQL endpoint puts on the wire: whatever the args declare as `rawResponse`, or
+ * `{ data: TResponse }` - the GraphQL-over-HTTP envelope the default unwrapping reads - when they
+ * declare none.
+ */
+type GqlRawResponseType<TArgs extends GqlQueryArgs> = 'rawResponse' extends keyof TArgs ? RawResponseType<TArgs> : {
+    data: ResponseType<TArgs>;
+};
 type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions<TArgs>, 'route' | 'transformResponse'> & {
     route?: RouteType<TArgs>;
     /**
-     * Optional custom transform function for GQL responses.
-     * If not provided, the default { data: ... } unwrapping will be used.
+     * Transforms the raw GraphQL response into the final response type. Optional: without one, the
+     * `{ data: ... }` envelope is unwrapped - which is all the default does, so args declaring an
+     * envelope the default cannot read need one.
      */
-    transformResponse?: CreateQueryCreatorOptions<TArgs>['transformResponse'];
+    transformResponse?: (rawResponse: GqlRawResponseType<TArgs>) => ResponseType<TArgs>;
 };
 type AnyCreateGqlQueryCreatorOptions = CreateGqlQueryCreatorOptions<any>;
 type GqlQueryMethod = 'QUERY' | 'MUTATE';
@@ -2768,9 +2805,7 @@ declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: Create
 
 type GqlQueryArgs<TResponse = unknown> = QueryArgs & {
     response: TResponse;
-    rawResponse?: {
-        data: TResponse;
-    };
+    rawResponse?: unknown;
     variables?: Record<string, unknown>;
 };
 type CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creator' | 'creatorInternals'> & {
@@ -3198,20 +3233,27 @@ declare const createQueryBatch: <TCreator extends AnyQueryCreator, TItem>(option
 
 declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
 declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
-declare const buildQueryCacheKey: (route: string, args: RequestArgs<QueryArgs> | undefined) => string;
-
-type QueryContext = {
-    /** All query dependencies (client, injector, destroy refs, etc.) */
-    deps: QueryDependencies;
-};
-declare const createQueryContext: (context: QueryContext) => _ethlete_core.StaticProviderDefinition<QueryContext>;
-declare const injectQueryContext: () => QueryContext;
+/**
+ * Builds the repository cache key for a request. `method` keeps two cacheable methods on one route
+ * (a `HEAD` and an `OPTIONS`, a GraphQL query over POST and a plain `GET`) in separate entries.
+ * Omitting it - or passing `GET` - yields the key a `GET` has always had, which is what persisted
+ * entries written by an older version are stored under.
+ */
+declare const buildQueryCacheKey: (route: string, args: RequestArgs<QueryArgs> | undefined, method?: QueryMethod) => string;
 
 type ConditionalOptions<TArgs extends QueryArgs> = RequiresTransform<TArgs> extends true ? [options: CreateQueryCreatorOptions<TArgs>] : [options?: CreateQueryCreatorOptions<TArgs>];
 /** A query creator that creates a GET query */
 declare const createGetQuery: (client: AnyCreateQueryClientResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
 /** A query creator that creates a secure GET query (requires authentication) */
 declare const createSecureGetQuery: (client: AnyCreateQueryClientResult, authProvider: AnyCreateBearerAuthProviderResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
+/** A query creator that creates a HEAD query */
+declare const createHeadQuery: (client: AnyCreateQueryClientResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
+/** A query creator that creates a secure HEAD query (requires authentication) */
+declare const createSecureHeadQuery: (client: AnyCreateQueryClientResult, authProvider: AnyCreateBearerAuthProviderResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
+/** A query creator that creates an OPTIONS query */
+declare const createOptionsQuery: (client: AnyCreateQueryClientResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
+/** A query creator that creates a secure OPTIONS query (requires authentication) */
+declare const createSecureOptionsQuery: (client: AnyCreateQueryClientResult, authProvider: AnyCreateBearerAuthProviderResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
 /** A query creator that creates a POST query */
 declare const createPostQuery: (client: AnyCreateQueryClientResult) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, ...args: ConditionalOptions<TArgs>) => QueryCreator<TArgs>;
 /** A query creator that creates a secure POST query (requires authentication) */
@@ -3289,11 +3331,6 @@ type QueryErrorParser = (detail: unknown, response: HttpErrorResponse) => string
  * query client features - reach for this directly only for an API shape the SDK does not know.
  */
 declare const registerQueryErrorParser: (parser: QueryErrorParser) => void;
-/**
- * Installs the retry policy used by every request that does not bring its own `retryFn`. Installed
- * by the {@link withDefaultRetry} query client feature; without it nothing is retried automatically.
- */
-declare const setDefaultQueryRetryFn: (fn: ShouldRetryRequestFn) => void;
 
 /**
  * Recovers the sentence inside an HTML error page (a proxy's 502, a maintenance page) and drops the
@@ -3362,6 +3399,7 @@ declare const QueryRuntimeErrorCode: {
     readonly QUERY_STACK_WITH_RESPONSE_UPDATE_USED: 501;
     readonly QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH: 502;
     readonly GQL_DATA_PROPERTY_MISSING_IN_RESPONSE: 600;
+    readonly GQL_ERRORS_IN_RESPONSE: 601;
     readonly TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC: 700;
     readonly INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701;
     readonly CIRCULAR_QUERY_DEPENDENCY: 800;
@@ -3375,7 +3413,7 @@ declare const QueryRuntimeErrorCode: {
     readonly LEGACY_INVALID_BODY: 954;
 };
 type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
-declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<0>;
+declare const queryFeatureUsedMultipleTimes: (type: string) => RuntimeError<0>;
 declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<100>;
 declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<101>;
 declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<102>;
@@ -3397,9 +3435,11 @@ declare const queryStackWithArgsUsed: () => RuntimeError<500>;
 declare const queryStackWithResponseUpdateUsed: () => RuntimeError<501>;
 declare const queryStackTotalQueriesAndExpectedQueriesMismatch: (totalQueries: number, expectedQueries: number) => RuntimeError<502>;
 declare const gqlDataPropertyMissingInResponse: () => RuntimeError<600>;
+declare const gqlErrorsInResponse: (errors: unknown[]) => HttpErrorResponse;
 declare const tokensNotAvailableInsideAuthAndExec: () => RuntimeError<700>;
 declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
 declare const circularQueryDependency: () => RuntimeError<800>;
+declare const queryExecutedAfterDestroyMessage: (route: unknown) => string;
 declare const legacyPrepareWithoutInjectionContext: (creatorName: string | undefined, method?: "prepare" | "createSubject" | "createSignal") => RuntimeError<950>;
 declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
 declare const queryBatchAlreadyRunning: () => RuntimeError<910>;
@@ -3443,8 +3483,9 @@ type QuerySequenceResult<TResponses extends unknown[]> = {
 type QuerySequence<TResponses extends unknown[]> = {
     /**
      * Appends a dependent step. `mapArgs` runs at {@link run} time and receives the previous step's
-     * (unwrapped, non-null on success) response plus the typed tuple of all responses so far, so a
-     * later step can still reach an earlier one's data.
+     * unwrapped response plus the typed tuple of all responses so far, so a later step can still reach
+     * an earlier one's data. A step that settles with no body (`204`) passes `null`, so declare such a
+     * step's `response` as nullable and the type follows.
      */
     then: <TArgs extends QueryArgs>(query: Query<TArgs>, mapArgs: (previousResponse: LastOf<TResponses>, responses: TResponses) => QuerySequenceStepArgs<TArgs>) => QuerySequence<[...TResponses, ResponseType<TArgs>]>;
     /** The current lifecycle phase - `idle` before the first run, then `running` → `success` | `error`. */
@@ -3460,7 +3501,7 @@ type QuerySequence<TResponses extends unknown[]> = {
      * `<et-progress-bar [value]>` or a button's `[progress]`. A run that fails stops where it stopped.
      */
     progress: Signal<number>;
-    /** The static number of steps in the sequence. */
+    /** The number of steps of the fully-built chain - every link built from the same seed reports it. */
     total: number;
     /** The query objects backing each step, in order. Useful for devtools / advanced introspection. */
     queries: AnyNewQuery[];
@@ -3485,8 +3526,9 @@ type QuerySequence<TResponses extends unknown[]> = {
      * succeed. Re-runnable (e.g. behind a retry button); throws {@link querySequenceAlreadyRunning}
      * if a run is already in flight.
      *
-     * Cancellation caveat (inherited from `executeUntilSettled`): if the host scope is destroyed
-     * mid-flight the in-flight query is torn down and this promise never settles.
+     * Cancellation (inherited from `executeUntilSettled`): a step whose request is cancelled - a
+     * destroyed host scope, an evicted cache entry - stops the waterfall like any other failure, with
+     * an error that says the request was cancelled.
      */
     run: () => Promise<QuerySequenceResult<TResponses>>;
 };
@@ -3534,7 +3576,7 @@ type ServerValidationError = ValidationError.WithOptionalFieldTree & {
  * Extracts the violation list from a failed request in any of the shapes it may reach you:
  * a `QueryErrorResponse` (from `query.error()` or a settled snapshot), a raw `HttpErrorResponse`,
  * an already-unwrapped error body, or a plain violation array. Returns `[]` when the error
- * carries no violations.
+ * carries no violations, including when its `violations` field is not a list of violations.
  */
 declare const extractFormViolations: (error: unknown) => FormViolationView[];
 type MapViolationsToFormErrorsOptions<TModel> = {
@@ -3569,9 +3611,10 @@ type MapViolationsToFormErrorsOptions<TModel> = {
  * Each violation's `propertyPath` (e.g. `items[2].name`) is resolved against `fieldTree`; a
  * resolved violation becomes a `ServerViolationValidationError` bound to that field, an
  * unresolved one becomes a form-level error (customizable via `onUnmappedViolation`). A failed
- * request that carries no violations at all degrades to form-level `ServerValidationError`s
- * built from the normalized error message - so returning this function's result from a
- * `submit()` action never silently succeeds on failure.
+ * request that carries no usable violations - none at all, or a malformed violation payload -
+ * degrades to form-level `ServerValidationError`s built from the normalized error message, so
+ * returning this function's result from a `submit()` action never silently succeeds on failure
+ * and never throws on an unexpected error shape.
  *
  * ```ts
  * await submit(this.form, async (field) => {
@@ -3601,8 +3644,9 @@ declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQu
  * Designed for imperative flows that need a mutation's outcome in place - e.g. a signal-forms
  * `submit()` action mapping server violations onto the form via `mapViolationsToFormErrors`.
  *
- * The promise stays pending if the execution is cancelled (e.g. `reset()`) and the query is never
- * executed again - the snapshot settles with whichever execution completes next.
+ * A cancelled execution settles too - the entry was evicted, unbound by a logout, or the scope that
+ * owns the query was destroyed. The snapshot then reports the execution as a failure whose error
+ * says the request was cancelled, and its `latestHttpEvent()` is `{ type: 'cancel' }`.
  */
 declare const executeUntilSettled: <TArgs extends QueryArgs>(query: Query<TArgs>, executeArgs?: QueryExecuteArgs<TArgs>) => Promise<QuerySnapshot<TArgs>>;
 
@@ -3766,7 +3810,7 @@ type CreateQuerySubmissionConfig<TCreator extends AnyQueryCreator, TModel> = {
      * Runs after the request succeeded, before the action resolves and the form leaves its submitting
      * state - notify, close the overlay, navigate.
      */
-    onSuccess?: (response: NonNullable<ResponseType<QueryArgsOf<TCreator>>>, field: FieldTree<TModel>) => void;
+    onSuccess?: (response: ResponseType<QueryArgsOf<TCreator>>, field: FieldTree<TModel>) => void;
     /**
      * Rewrites a violation's property path before it is resolved against the field tree - use it when
      * the API's payload shape differs from the form model. Return `null` to leave the violation
@@ -3775,7 +3819,8 @@ type CreateQuerySubmissionConfig<TCreator extends AnyQueryCreator, TModel> = {
     rewritePath?: (path: string, violation: FormViolationView) => string | null;
     /**
      * Override the default violation → error mapping. Receives the failed request's error; return the
-     * errors to report. Defaults to `mapViolationsToFormErrors` against the submitted field.
+     * errors to report, used as-is - `null` / `undefined` attaches nothing. Defaults to
+     * `mapViolationsToFormErrors` against the submitted field.
      */
     mapViolations?: (error: unknown, field: FieldTree<TModel>) => TreeValidationResult;
 };
@@ -3845,7 +3890,9 @@ type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
      * 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;
+    transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> & {
+        args: RequestArgs<TArgs>;
+    }, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
 };
 declare const createSecureExecuteFactory: <TArgs extends QueryArgs>(options: SecureExecuteFactoryOptions<TArgs>) => InternalQueryExecute<TArgs>;
 
@@ -3871,6 +3918,7 @@ type ValidateWithQueryConfig<TCreator extends AnyQueryCreator, TValue, TPathKind
     /**
      * Override the default violation → error mapping. Receives the violations extracted from the
      * failed request; return the errors to report (targeting child fields via their `fieldTree`).
+     * Runs only for a request that carries violations - any other error keeps the form-level error.
      * Defaults to `mapViolationsToFormErrors`, resolving each violation's `propertyPath` against the
      * validated field.
      */
@@ -4214,7 +4262,8 @@ type PersistentAuthConfig<TBuilders extends readonly AnyQueryBuilder[], TKey ext
          */
         name?: string;
         /**
-         * The domain of the cookie. If not set, the current origin will be used.
+         * The domain of the cookie. If not set, the cookie is host-only: it belongs to the exact host that
+         * wrote it and no subdomain of it. Set this only when sibling subdomains must share the session.
          */
         domain?: string;
         /**
@@ -4306,6 +4355,12 @@ type TokenExpirationWarningConfig = {
      * @default 1000 (1 second)
      */
     checkInterval?: number;
+    /**
+     * Name of the claim in the decoded access token that carries the expiry, as seconds since the epoch.
+     * Must match the `expiresInPropertyName` of the refresh query.
+     * @default 'exp'
+     */
+    expiresInPropertyName?: string;
 };
 type TokenExpirationWarningFeature = {
     /**
@@ -4409,12 +4464,14 @@ type LeaderInstanceCountChangeEventData = {
     count: number;
 };
 type TrackingEventDataMap<TBuilders extends readonly AnyQueryBuilder[]> = {
-    [K in TrackingEventName<TBuilders>]: K extends `${string}Execute` ? QueryExecuteEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Success` ? QuerySuccessEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Failure` ? QueryFailureEventData : K extends 'tokenRefreshSuccess' ? TokenRefreshEventData : K extends 'logout' ? LogoutEventData : K extends 'leaderStatusChange' ? LeaderStatusChangeEventData : K extends 'leaderInstanceCountChange' ? LeaderInstanceCountChangeEventData : never;
+    [K in TrackingEventName<TBuilders>]: K extends 'tokenRefreshSuccess' ? TokenRefreshEventData : K extends 'logout' ? LogoutEventData : K extends 'leaderStatusChange' ? LeaderStatusChangeEventData : K extends 'leaderInstanceCountChange' ? LeaderInstanceCountChangeEventData : K extends `${string}Execute` ? QueryExecuteEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Success` ? QuerySuccessEventData<ExtractArgsForEvent<TBuilders, K>> : K extends `${string}Failure` ? QueryFailureEventData : never;
 };
 type TrackingEventHandler<TData> = (data: TData) => void;
 type TrackingConfig<TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[]> = {
     /**
-     * Whether to track internal events (auto token refresh, etc.)
+     * Whether executions the provider starts itself - the persistent auto-login, the proactive token
+     * refresh, the token revocation - also raise their `<key>Execute` / `<key>Success` / `<key>Failure`
+     * events.
      * @default true
      */
     trackInternalEvents?: boolean;
@@ -4561,10 +4618,19 @@ type BearerAuthProviderEarlySetupContext = {
  * `withBearerAuthMultiTabSync`; absent when every tab refreshes for itself.
  */
 type BearerAuthRefreshCoordination = {
-    /** Asks the leader tab to refresh the session's tokens now. */
-    request: () => void;
-    /** Emits in the leader tab whenever another tab asked for a refresh. */
-    requests$: Observable<void>;
+    /**
+     * Asks the leader tab to refresh the session's tokens now, with the access token this tab holds. The
+     * leader answers a request made with a token it has already rotated past by sending its current pair
+     * instead of spending another refresh token.
+     */
+    request: (accessToken?: string | null) => void;
+    /**
+     * Emits in the leader tab whenever another tab asked for a refresh, carrying the access token that
+     * tab asked with - `null` when it held none, or ran a version that did not send one.
+     */
+    requests$: Observable<string | null>;
+    /** Sends the token pair this tab holds to the others, which is how a request is answered without a refresh. */
+    answerWithCurrentTokens?: () => void;
     /**
      * Tells the other tabs that a refresh started here. It is what makes {@link request} more than a
      * message into the void: a follower that gets no answer takes the refresh over itself, so a leader
@@ -5244,7 +5310,8 @@ type QueryDevtoolsSettings = {
     /**
      * The session vault: the token pairs the panel switches between, and the credentials it logs in with.
      * `local` by default, because a vault that forgets the other user on every reload is not one - and
-     * `none` for a machine where nothing of the sort may be kept.
+     * `none` for a machine where nothing of the sort may be kept. Outside a development build `local` is
+     * refused and read back as `session`, see {@link queryDevtoolsAllowsLocalAuthSessions}.
      */
     authSessions: QueryDevtoolsStorageScope;
     /** How many entries the Events log keeps. */
@@ -5296,6 +5363,15 @@ declare const writeQueryDevtoolsStore: (scope: QueryDevtoolsStorageScope, key: s
  * Part of the devtools contract. **Not part of the general public contract.**
  */
 declare const clearQueryDevtoolsStore: (key: string) => void;
+/**
+ * Whether the session vault may be kept in `localStorage`. Only a development build may: the vault
+ * holds live access and refresh tokens plus the credentials somebody typed in, and a deployed
+ * application that mounts the panel for its debugging value must not leave those on the machine of
+ * whoever opened it. Every other scope stays on offer, so the vault still works for one tab.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const queryDevtoolsAllowsLocalAuthSessions: () => boolean;
 /**
  * Changes part of the devtools configuration and stores it. Values outside the range a field allows are
  * clamped rather than rejected.
@@ -5574,6 +5650,15 @@ type QueryDevtoolsRegistration = {
 };
 /** The registry {@link provideQueryDevtools} installs. */
 type QueryDevtoolsRegistrar = (entry: QueryDevtoolsRegistration) => () => void;
+/**
+ * Whether `provideQueryDevtools()` has been called on this page. When `false` every instrumentation
+ * site is a no-op, which is what a devtools UI gates itself on so a build that omits the provider
+ * renders nothing.
+ *
+ * It is answered by the `provideQueryDevtools()` call itself, which runs while the providers array is
+ * built - so it is already settled by the time an application bootstraps and needs no signal.
+ */
+declare const isQueryDevtoolsEnabled: () => boolean;
 /** The request an upcoming attempt belongs to, for the fault resolver to match against. */
 type QueryDevtoolsFaultTarget = {
     /** Display name of the owning query client. Faults are armed per client. */
@@ -5640,6 +5725,17 @@ type QueryDevtoolsAuthSeed = {
     refreshToken: string;
 };
 
+/**
+ * Whether the client that owns a repository is still alive. A destroyed client's queries survive as
+ * tombstones, which keep their `meta.repository`, so this is the only way to tell a dead client from
+ * one whose queries all happen to be destroyed.
+ *
+ * Reads a version signal, so a computed that calls it recomputes as clients come and go.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+declare const isQueryDevtoolsRepositoryLive: (repository: QueryRepository) => boolean;
+
 /**
  * A response designed in the devtools panel and served in place of a request. An override edits what came
  * back; a mock replaces the request itself, so it can be armed for a route that has never run - or does
@@ -6034,6 +6130,9 @@ type QueryDevtoolsOptions = {
  * When omitted, all devtools instrumentation is a no-op: the registry is never installed, so nothing
  * is retained at runtime and the registry itself is dropped from the bundle.
  *
+ * The options are read once, on the first call. A second application on the same page keeps the
+ * options of the first one, and this call warns about the ones it declared itself.
+ *
  * @example
  * ```ts
  * bootstrapApplication(AppComponent, {
@@ -6125,8 +6224,9 @@ declare const MAX_QUERY_BATCH_TOMBSTONES = 20;
 declare const snapshotQueryDevtoolsHandle: (handle: unknown) => unknown;
 /**
  * The entry a destroyed query leaves behind: the same id, kind and metadata, a frozen
- * {@link snapshotQueryDevtoolsHandle} in place of the live query, and no `element` - a DOM node whose
- * component is gone must not be kept alive by the panel.
+ * {@link snapshotQueryDevtoolsHandle} in place of the live query, and neither `element` nor
+ * `queryConfig.injector` - a DOM node whose component is gone, and the `NodeInjector` that reaches the
+ * same view through its `LView`, must not be kept alive by the panel.
  *
  * `stats` is carried over as-is. The recorder closes over its own signals rather than over the query,
  * so the run history that makes a failed request readable survives without retaining anything.
@@ -6149,10 +6249,15 @@ declare const setQueryDevtoolsUiMounted: (isMounted: boolean) => void;
 
 type TransformedGqlQuery = {
     query: string;
-    variables?: string;
+    variables?: string | Record<string, unknown>;
     operationName?: string;
 };
-type GqlTransformer = (variables: Record<string, unknown> | null | undefined) => TransformedGqlQuery;
+type GqlTransformer = (variables: Record<string, unknown> | null | undefined, transport?: GqlQueryTransport) => TransformedGqlQuery;
+/**
+ * Builds the GraphQL-over-HTTP payload of a document. `variables` comes back as a JSON string for
+ * the `GET` transport (the default), where the payload travels as query parameters, and as the map
+ * itself for `POST`, where it travels as a JSON body.
+ */
 declare const transformGql: (str: string | string[]) => GqlTransformer;
 type GQL = string & {
     readonly __gql: unique symbol;
@@ -6411,6 +6516,32 @@ type RequestEvent<Response = unknown> = {
  */
 declare const request: <Response = unknown>(config: RequestConfig) => Observable<RequestEvent<Response>>;
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const buildQueryString: (params: _ethlete_query.QueryParams, config?: _ethlete_query.BuildQueryStringConfig) => string | null;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const buildRoute: (options: {
+    base: string;
+    route: RouteInput | null | undefined;
+    pathParams?: _ethlete_query.PathParams;
+    queryParams?: _ethlete_query.QueryParams;
+    queryParamConfig?: _ethlete_query.BuildQueryStringConfig;
+}) => string;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const isEmptyString: (value: unknown) => boolean;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const isNaN: (value: unknown) => boolean;
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
@@ -6480,11 +6611,12 @@ type QueryFieldOptions<T = unknown> = {
     /**
      * Append the field's value to the url.
      *
-     * The field wont be appended to the url if one of the following is true:
-     * - It is the default value and `appendDefaultValueToUrl` is `false`
-     * - It is an empty string
-     * - It is `null`
-     * - It is `undefined`
+     * The field is removed from the url while it holds its default value, unless
+     * `appendDefaultValueToUrl` is `true`. Any other value is written - a `null` as the `ET_NULL__`
+     * sentinel it reads back from, an empty string as an empty param.
+     *
+     * `false` means the field mirrors a param another owner writes: the form neither writes nor
+     * removes that param, and a foreign write to it still reaches the field.
      *
      * @default true
      */
@@ -6559,6 +6691,7 @@ type QueryFormGroupControls<T extends Record<string, QueryField<any>>> = {
 type QueryFormValue<T extends Record<string, QueryField<any>>> = {
     [Property in keyof T]: T[Property]['control']['value'];
 };
+/** @deprecated Use `defineQueryForm`. */
 type QueryFormOf<T extends FormGroup> = {
     [K in keyof T['controls']]: QueryField<T['controls'][K]['value']>;
 };
@@ -6686,6 +6819,7 @@ type QueryFormOptions = {
      */
     queryParamPrefix?: string | (() => string);
 };
+/** @deprecated Use `defineQueryForm`. */
 type AnyQueryForm = QueryForm<any>;
 /** @deprecated Use `defineQueryForm`. */
 declare class QueryForm<T extends Record<string, QueryField<any>>> {
@@ -6701,6 +6835,8 @@ declare class QueryForm<T extends Record<string, QueryField<any>>> {
     private isObserving;
     private removeQueryParamsOnCleanup;
     private skipNextResets;
+    private skipNextDebounce;
+    private skipNextResetsFor;
     private urlWriteVersion;
     private readonly urlNavigationMarker;
     private queryParamChanges$;
@@ -6749,6 +6885,7 @@ declare class QueryForm<T extends Record<string, QueryField<any>>> {
     unobserve(): void;
     setFormValueFromUrlQueryParams(options: {
         queryParams: Record<string, unknown>;
+        onlyFieldsTheFormNeverWrites?: boolean;
     }): boolean;
     setValue(value: QueryFormValue<T>, options?: QueryFormWriteOptions): void;
     patchValue(value: Partial<QueryFormValue<T>>, options?: QueryFormWriteOptions): void;
@@ -6768,6 +6905,8 @@ declare class QueryForm<T extends Record<string, QueryField<any>>> {
     private _syncViaUrlQueryParams;
     private handleFormChange;
     private cleanup;
+    private navigateWithParams;
+    private pathOf;
 }
 
 /**
@@ -6786,6 +6925,10 @@ declare class QueryForm<T extends Record<string, QueryField<any>>> {
  * requests, which is data bleed rather than a leak. Server-side renders keep throwing `ET950`, so a call
  * site that only works in the browser fails loudly where it matters.
  *
+ * With several applications on one page it stays a single module-global slot: the application that
+ * provided it first answers every `prepare()` made outside an injection context, whichever application
+ * made the call, until that application is destroyed. Dev mode warns when a second one registers.
+ *
  * Prefer passing `injector` at the call site - it keeps the query scoped to whatever created it. Reach for
  * this when a migration has too many call sites to thread by hand.
  *
@@ -6809,7 +6952,7 @@ type CreateLegacyQueryOptions<TArgs extends QueryArgs> = {
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
-declare const transformExecStateToQueryState: <TArgs extends QueryArgs>(execState: QueryExecutionState<TArgs> | null) => V2QueryState<ResponseType<TArgs>>;
+declare const transformExecStateToQueryState: <TArgs extends QueryArgs>(execState: QueryExecutionState<TArgs> | null, triggeredVia?: QueryTrigger) => V2QueryState<ResponseType<TArgs>>;
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
@@ -6826,6 +6969,8 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
     _arguments: RequestArgs<QueryArgsOf<TNewQuery>>;
     entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined;
     private isDestroyed;
+    private _triggeredVia;
+    private _wasAborted;
     state$: Observable<V2QueryState<Data>>;
     constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined, 
     /**
@@ -6842,7 +6987,12 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
      * @internal
      */
     _canBeCached?: boolean);
-    get rawState(): V2QueryState<any>;
+    get rawState(): V2QueryState<ResponseType<QueryArgsOf<TNewQuery>>>;
+    /**
+     * `abort()` resets the underlying query, so it holds no execution state - the shape of a query that has
+     * never run. The abort flag is the only thing that tells the two apart.
+     */
+    private toQueryState;
     get isExpired(): boolean | undefined;
     get isInUse(): boolean;
     get isPolling(): boolean;
@@ -7365,7 +7515,7 @@ type WithMock<MockResponse> = {
  */
 type V2QueryConfig = {
     /**
-     * Whether this query should be added to the internal query store.
+     * Whether this query should be kept out of the internal query store, so it is neither cached nor shared.
      *
      * Generally this should be left on `false` unless you know what you are doing.
      * @default false
@@ -7638,6 +7788,7 @@ declare class V2Query<Response, Arguments extends BaseArguments | undefined, Rou
     private pollingSubscription;
     private onAbort$;
     private currentPollConfig;
+    private pollStopSubscription;
     private memoizedState$;
     private readonly _state$;
     constructor(_client: V2QueryClient, 
@@ -7966,9 +8117,13 @@ declare class V2QueryClient {
  */
 declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "OPTIONS" | "HEAD" | "GQL_QUERY";
 /**
+ * Builds the query store key for a request. `method` keeps two cacheable methods on one route
+ * (a `HEAD` and an `OPTIONS`, a `GQL_QUERY` over POST and a plain `GET`) in separate entries.
+ * Omitting it - or passing `GET` - yields the key a `GET` has always had.
+ *
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
-declare const v2BuildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;
+declare const v2BuildQueryCacheKey: (route: string, args: BaseArguments | undefined, method?: Method) => string;
 
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
@@ -7978,6 +8133,8 @@ declare class QueryStore {
     private garbageCollector;
     private isInLowResourceMode;
     private lastBlurTimestamp;
+    private isDestroyed;
+    private readonly subscriptions;
     private _storeChange$;
     private _queryCreated$;
     readonly storeChange$: rxjs.Observable<string>;
@@ -8240,6 +8397,7 @@ declare class BasicAuthProvider implements AuthProvider {
 declare class V2BearerAuthProvider<T extends AnyV2QueryCreator> implements AuthProvider {
     _config: AuthProviderBearerConfig<T>;
     private destroy$;
+    private refreshTimerSubscription;
     private readonly _currentRefreshQuery$;
     private readonly _tokens$;
     constructor(_config: AuthProviderBearerConfig<T>);
@@ -8249,7 +8407,9 @@ declare class V2BearerAuthProvider<T extends AnyV2QueryCreator> implements AuthP
     get currentRefreshQuery$(): rxjs.Observable<ConstructQuery<T> | null>;
     get currentRefreshQuery(): ConstructQuery<T> | null;
     get shouldRefreshOnUnauthorizedResponse(): boolean;
-    cleanUp(): void;
+    cleanUp(options?: {
+        endSession?: boolean;
+    }): void;
     enableCookie(): void;
     disableCookie(): void;
     forceRefresh(): _ethlete_query.V2Query<any, any, any, any, any, any> | undefined;
@@ -8270,6 +8430,10 @@ declare const isBearerAuthProvider: <T extends AnyV2QueryCreator>(authProvider:
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 declare const isCustomHeaderAuthProvider: (authProvider: AuthProvider) => authProvider is CustomHeaderAuthProvider;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const decryptBearer: <Result = Record<string, unknown>>(token: string) => Result | null;
 
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
@@ -8497,6 +8661,11 @@ type InfinityQueryConfig<QueryCreator extends AnyV2QueryCreator | AnyLegacyQuery
      * The args that will be merged with the page arg.
      */
     defaultArgs?: Arguments & WithHeaders;
+    /**
+     * The injector each page is prepared with. Required for a creator made by `createLegacyQueryCreator()`, which
+     * cannot resolve one on its own. `[etInfinityQuery]` fills this in with its own injector.
+     */
+    injector?: Injector;
     /**
      * Enables or disables the infinite query functionality.
      * @default true
@@ -8651,7 +8820,7 @@ type DirectiveQueryCreator = AnyV2QueryCreator | AnyLegacyQueryCreator;
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
-declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>> {
+declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>> implements OnInit {
     private readonly queryConfigChanged$;
     private readonly viewContext;
     private infinityQueryInstance;
@@ -8660,6 +8829,7 @@ declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQuer
     private viewContainerRef;
     private mainTemplateRef;
     private errorHandler;
+    private injector;
     private infinityQueryResponseDelay;
     private readonly _data$;
     get infinityQuery(): Q;
@@ -8670,7 +8840,7 @@ declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQuer
     get data$(): rxjs.Observable<Q["response"]["arrayType"]>;
     data: _angular_core.Signal<Q["response"]["arrayType"]>;
     static ngTemplateContextGuard<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>>(_dir: InfinityQueryDirective<Q>, _ctx: unknown): _ctx is InfinityQueryContext<Q>;
-    constructor();
+    ngOnInit(): void;
     private setupInfinityQuery;
     loadNextPage(): void;
     reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
@@ -8689,6 +8859,7 @@ declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy {
     infinityQueryOverride: _angular_core.InputSignal<InfinityQueryDirective<any> | null>;
     private destroy;
     private observer;
+    private isIntersecting;
     click$: rxjs.Observable<Event>;
     infinityQuery: _angular_core.Signal<InfinityQueryDirective<any>>;
     ngOnInit(): void;
@@ -8755,6 +8926,18 @@ declare class QueryDirective<Q extends QueryDirectiveType | null> {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, { "query": { "alias": "etQuery"; "required": true; "isSignal": true; }; "cache": { "alias": "etQueryCache"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const invalidBaseRouteError: (data: unknown) => RuntimeError<1>;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const invalidRouteError: (data: unknown) => RuntimeError<2>;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+declare const pathParamsMissingInRouteFunctionError: (data: unknown) => RuntimeError<3>;
 /**
  * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
@@ -8804,6 +8987,7 @@ type ValidateWithV2QueryConfig<TCreator extends AnyV2QueryCreator | AnyLegacyQue
     /**
      * Override the default violation → error mapping. Receives the violations extracted from the
      * failed request; return the errors to report (targeting child fields via their `fieldTree`).
+     * Runs only for a request that carries violations - any other error keeps the form-level error.
      * Defaults to `mapViolationsToFormErrors`, resolving each violation's `propertyPath` against the
      * validated field.
      */
@@ -8836,30 +9020,30 @@ type ValidateWithV2QueryConfig<TCreator extends AnyV2QueryCreator | AnyLegacyQue
  */
 declare const validateWithV2Query: <TCreator extends AnyV2QueryCreator | AnyLegacyQueryCreator, TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, config: ValidateWithV2QueryConfig<TCreator, TValue, TPathKind>) => void;
 
-declare const parseHttpErrorCodeToTitleDe: (statusCode: HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Weg" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Bereich nicht zufriedenstellend" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
-declare const parseHttpErrorCodeToMessageDe: (statusCode: HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
+declare const parseHttpErrorCodeToTitleDe: (statusCode: HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Nicht mehr verfügbar" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Seite nicht vorhanden" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
+declare const parseHttpErrorCodeToMessageDe: (statusCode: HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat zu lange auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Die angeforderte Seite existiert nicht. Gehen Sie zurück zur ersten Seite und versuchen Sie es erneut." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server verarbeitet die Anforderung nicht, weil sie eine Wiederholung sein könnte. Bitte versuchen Sie es erneut." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
 
 declare class ParseHttpErrorCodeToTitleDePipe implements PipeTransform {
-    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Weg" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Bereich nicht zufriedenstellend" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
+    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Nicht mehr verfügbar" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Seite nicht vorhanden" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleDePipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleDePipe, "parseHttpErrorCodeToTitleDe", true>;
 }
 declare class ParseHttpErrorCodeToMessageDePipe implements PipeTransform {
-    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
+    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat zu lange auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Die angeforderte Seite existiert nicht. Gehen Sie zurück zur ersten Seite und versuchen Sie es erneut." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server verarbeitet die Anforderung nicht, weil sie eine Wiederholung sein könnte. Bitte versuchen Sie es erneut." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageDePipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageDePipe, "parseHttpErrorCodeToMessageDe", true>;
 }
 
-declare const parseHttpErrorCodeToTitleEn: (statusCode: HttpStatusCode) => "Unauthorized" | "Forbidden" | "Bad request" | "Payment required" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Range not satisfiable" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
-declare const parseHttpErrorCodeToMessageEn: (statusCode: HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The client has asked for a portion of the file, but the server cannot supply that portion." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server is unwilling to process the request because the user has not been authenticated." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
+declare const parseHttpErrorCodeToTitleEn: (statusCode: HttpStatusCode) => "Unauthorized" | "Forbidden" | "Bad request" | "Payment required" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Page out of range" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
+declare const parseHttpErrorCodeToMessageEn: (statusCode: HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The requested page does not exist. Go back to the first page and try again." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server refuses to process a request that could be a replay. Please try again." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
 
 declare class ParseHttpErrorCodeToTitleEnPipe implements PipeTransform {
-    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Unauthorized" | "Forbidden" | "Bad request" | "Payment required" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Range not satisfiable" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
+    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Unauthorized" | "Forbidden" | "Bad request" | "Payment required" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Page out of range" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleEnPipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleEnPipe, "parseHttpErrorCodeToTitleEn", true>;
 }
 declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
-    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The client has asked for a portion of the file, but the server cannot supply that portion." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server is unwilling to process the request because the user has not been authenticated." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
+    transform: (statusCode: _angular_common_http.HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The requested page does not exist. Go back to the first page and try again." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server refuses to process a request that could be a replay. Please try again." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageEnPipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageEnPipe, "parseHttpErrorCodeToMessageEn", true>;
 }
@@ -8915,7 +9099,7 @@ type QueryFieldDef<T> = {
     readonly skipInFilterCount?: boolean;
     /**
      * Skip the best-effort auto-coercion (numeric strings → number, `'true'`/`'false'`
-     * → boolean, the null sentinel → `null`) when reading the value back from the URL.
+     * → boolean, the null and empty-list sentinels → `null` and `[]`) when reading the value back from the URL.
      *
      * @default false
      */
@@ -8998,15 +9182,17 @@ type QueryFormSignalsWriteOptions = {
 declare const IGNORED_FILTER_COUNT_FIELDS: readonly string[];
 /**
  * A detached editor over the same fields - its own signal-forms form and value,
- * with no URL sync and no reset graph. Written back to the source form via
- * `source.setValue(branch.value())`. Powers the filter-overlay "edit then apply"
- * pattern (see `10-filter.md`).
+ * with no URL sync but the same debounce and `isResetBy` graph. Written back to
+ * the source form via `source.setValue(branch.liveValue())`. Powers the
+ * filter-overlay "edit then apply" pattern.
  */
 type QueryFormBranch<TFields extends QueryFormFields> = {
     /** The bindable signal-forms field tree (`branch.fields.search`). */
     readonly fields: FieldTree<QueryFormModel<TFields>>;
-    /** The live (undebounced) value of the branch. */
+    /** The committed value of the branch - debounced and reset-resolved like the source form's `value`. */
     readonly value: Signal<QueryFormModel<TFields>>;
+    /** What the bound controls hold right now, ahead of any pending debounce. Apply this on an explicit submit. */
+    readonly liveValue: Signal<QueryFormModel<TFields>>;
     /** The number of active (non-default) filters in the branch. */
     readonly activeFilterCount: Signal<number>;
     setValue(value: QueryFormModel<TFields>): void;
@@ -9057,7 +9243,12 @@ type QueryFormSignals<TFields extends QueryFormFields> = {
     readonly defaultValue: QueryFormModel<TFields>;
     /** Start syncing with the URL. Returns the form, so it can be chained onto the definition. */
     observe(options?: QueryFormSignalsObserveOptions): QueryFormSignals<TFields>;
-    /** Stop syncing and strip the form's params from the URL. Runs on destroy anyway. */
+    /**
+     * Stop syncing and strip the form's params from the URL. A pending debounced edit is committed to `value`
+     * but not written to the URL. Only an explicit call strips the params - the
+     * form stops syncing when it is destroyed, but leaves the URL alone, because the route it lands on
+     * owns the params by then.
+     */
     unobserve(): void;
     setValue(value: QueryFormModel<TFields>, options?: QueryFormSignalsWriteOptions): void;
     patchValue(value: Partial<QueryFormModel<TFields>>, options?: QueryFormSignalsWriteOptions): void;
@@ -9095,7 +9286,7 @@ declare const defineQueryForm: <TFields extends QueryFormFields>(config: DefineQ
 declare const queryField: <T = string>(config?: QueryFieldConfig<T | null>) => QueryFieldDef<T | null>;
 /**
  * A debounced free-text search field. Debounces typing by 300ms but applies
- * clearing immediately (`disableDebounceIfFalsy`).
+ * clearing immediately (`disableDebounceIfFalsy`). Reads the URL value back as the raw string.
  */
 declare const searchQueryField: (config?: QueryFieldConfig<string | null>) => QueryFieldDef<string | null>;
 /**
@@ -9158,6 +9349,8 @@ type WebSocketClientSocket = {
     emit: (event: string, data: unknown) => void;
     on: (event: 'connect' | 'disconnect', listener: () => void) => void;
     onAny: (listener: (eventName: string, ...args: unknown[]) => void) => void;
+    onAnyOutgoing: (listener: (eventName: string, ...args: unknown[]) => void) => void;
+    readonly recovered: boolean;
 };
 /**
  * The `io` factory of `socket.io-client`, declared structurally.
@@ -9202,7 +9395,8 @@ type WebSocketClientSubtle = {
 };
 type WebSocketClient<TMessageData extends SocketMessageView> = {
     /**
-     * Join a socket io room
+     * Join a socket io room. Must be called in an injection context, because the room is released when
+     * that context is destroyed.
      * If a function is passed, it will be evaluated in a reactive signal context.
      * If the function returns null, no room will be joined.
      * If the function returns a string, the previous room will be left and the new room will be joined.
@@ -9230,7 +9424,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.44";
+declare const QUERY_VERSION = "6.0.0-next.46";
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, 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, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, 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, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, 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, BearerAuthSessionAdoption, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryBatchOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySubmissionConfig, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, 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, QueryBatch, QueryBatchDevtoolsHandle, QueryBatchItemCancelled, QueryBatchItemError, QueryBatchItemResult, QueryBatchItemSkipped, QueryBatchItemSuccess, QueryBatchResult, QueryBatchStatus, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsApiEnv, QueryDevtoolsApiEnvSwitch, QueryDevtoolsAppInfo, QueryDevtoolsAuthAccount, QueryDevtoolsAuthAccountView, QueryDevtoolsAuthField, QueryDevtoolsAuthLocalAccount, QueryDevtoolsAuthProviderHandle, QueryDevtoolsAuthProviderRegistration, QueryDevtoolsAuthQuery, QueryDevtoolsAuthSeed, QueryDevtoolsAuthSession, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateFailureWithCachedResponse, QueryExecutionStateFailureWithNoResponse, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockHoldOptions, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubmissionRef, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, 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, BearerAuthSessionAdoption, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryBatchOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySubmissionConfig, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlRawResponseType, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpCancelEvent, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryBatch, QueryBatchDevtoolsHandle, QueryBatchItemCancelled, QueryBatchItemError, QueryBatchItemResult, QueryBatchItemSkipped, QueryBatchItemSuccess, QueryBatchResult, QueryBatchStatus, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsApiEnv, QueryDevtoolsApiEnvSwitch, QueryDevtoolsAppInfo, QueryDevtoolsAuthAccount, QueryDevtoolsAuthAccountView, QueryDevtoolsAuthField, QueryDevtoolsAuthLocalAccount, QueryDevtoolsAuthProviderHandle, QueryDevtoolsAuthProviderRegistration, QueryDevtoolsAuthQuery, QueryDevtoolsAuthSeed, QueryDevtoolsAuthSession, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateFailureWithCachedResponse, QueryExecutionStateFailureWithNoResponse, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockHoldOptions, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubmissionRef, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, 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 };