@ethlete/query 6.0.0-next.2 → 6.0.0-next.20

package/types/ethlete-query.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ɵEffectScheduler as _EffectScheduler, ErrorHandler, WritableSignal, CreateEffectOptions } from '@angular/core';
+import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, CreateEffectOptions, EnvironmentProviders } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
 import { ProviderResult, RuntimeError } from '@ethlete/core';
 import * as rxjs from 'rxjs';
@@ -7,7 +7,8 @@ import { Observable, Subscribable, BehaviorSubject } from 'rxjs';
 import * as _angular_common_http from '@angular/common/http';
 import { HttpErrorResponse, HttpHeaders, HttpClient, HttpEvent, HttpStatusCode } from '@angular/common/http';
 import * as _ethlete_query from '@ethlete/query';
-import { Paginated, NormalizedPagination, ContentfulGqlLikePaginated, DynLikePaginated, GgLikePaginated, FormViolationListView, FormViolationView } from '@ethlete/types';
+import { Paginated, FormViolationView, NormalizedPagination, ContentfulGqlLikePaginated, DynLikePaginated, GgLikePaginated, FormViolationListView } from '@ethlete/types';
+import { PathKind, FieldContext, TreeValidationResult, SchemaPath, SchemaPathRules, FieldTree, ValidationError } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
 import { FormControl, FormGroup } from '@angular/forms';
 import { ToObservableOptions, ToSignalOptions } from '@angular/core/rxjs-interop';
@@ -66,7 +67,7 @@ declare function mapToPaginated<T>(response: Paginated<T>): rxjs.OperatorFunctio
 /**
  * Use an other store to represent a property of the current entity.
  */
-declare const insertFrom: <OriginStoreType, OriginKeys extends keyof NonNullable<OriginStoreType>, SubStoreType extends NonNullable<OriginStoreType>[OriginKeys] extends Array<infer U> ? U : NonNullable<OriginStoreType>[OriginKeys], IdFn extends (value: NonNullable<OriginStoreType>) => EntityKey | EntityKey[], ComputedEntityType extends ReturnType<IdFn> extends Array<unknown> ? OriginStoreType : Omit<OriginStoreType, OriginKeys> & { [K in OriginKeys]: SubStoreType | null; }>(store: EntityStore<SubStoreType>, { for: key, id }: InsertFromConfig<OriginStoreType, OriginKeys, IdFn>) => rxjs.OperatorFunction<OriginStoreType, ComputedEntityType | null>;
+declare const insertFrom: <OriginStoreType, OriginKeys extends keyof NonNullable<OriginStoreType>, SubStoreType extends (NonNullable<OriginStoreType>[OriginKeys] extends Array<infer U> ? U : NonNullable<OriginStoreType>[OriginKeys]), IdFn extends (value: NonNullable<OriginStoreType>) => EntityKey | EntityKey[], ComputedEntityType extends (ReturnType<IdFn> extends Array<unknown> ? OriginStoreType : Omit<OriginStoreType, OriginKeys> & { [K in OriginKeys]: SubStoreType | null; })>(store: EntityStore<SubStoreType>, { for: key, id }: InsertFromConfig<OriginStoreType, OriginKeys, IdFn>) => rxjs.OperatorFunction<OriginStoreType, ComputedEntityType | null>;
 /**
  * Remove entities from a store based on a where function.
  */
@@ -222,7 +223,7 @@ declare const serializeBody: (body: unknown) => ArrayBuffer | URLSearchParams |
 declare const transformMethod: (config: {
     method: Method;
     transferVia?: "GET" | "POST";
-}) => "GET" | "POST" | "OPTIONS" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 declare const detectContentTypeHeader: (body: unknown) => string | null;
 declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
 declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
@@ -544,6 +545,7 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
     newQuery: TNewQuery;
     _arguments: RequestArgs<QueryArgsOf<TNewQuery>>;
     entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined;
+    private _isDestroyed;
     state$: Observable<V2QueryState<Data>>;
     get rawState(): V2QueryState<any>;
     get isExpired(): boolean | undefined;
@@ -553,7 +555,15 @@ declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined,
     get store(): null;
     get canBeCached(): boolean;
     get _isInMockMode(): boolean;
-    constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined);
+    constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined, 
+    /**
+     * Wraps an inert query — see `createInertQuery`. Skips everything that needs a live injector,
+     * so the wrapper is safe to build during teardown.
+     *
+     * @internal
+     */
+    _isInert?: boolean);
+    private _teardown;
     destroy(): void;
     execute(options?: ExecuteQueryOptions): this;
     abort(): this;
@@ -645,6 +655,12 @@ type CreateLegacyQueryCreatorOptions<TArgs extends QueryArgs, Response, Store ex
      * Object containing the query's entity store information.
      */
     entity?: QueryEntityConfig<Store, Data, Response, LegacyArgumentsOfQueryArgs<TArgs>, Id>;
+    /**
+     * The name this creator is exported under, used to name it in error messages. Emitted by the
+     * `migrate-to-query-v3` generator; worth passing by hand too, since without it a `prepare()`
+     * called outside an injection context can only be located by bisection.
+     */
+    name?: string;
 };
 type WithLegacyConfig = {
     /**
@@ -1046,7 +1062,10 @@ type QueryCollectionOf<T extends {
         query: ConstructQuery<T[K]>;
     };
 }[keyof T];
-type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
+type AnyQueryCollection = {
+    type: string;
+    query: AnyV2Query | AnyLegacyQuery;
+};
 type QueryOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyV2Query | null> = T extends AnyV2Query ? T : T extends AnyLegacyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
 type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;
 type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;
@@ -1148,7 +1167,7 @@ declare const isQueryCollection: <T extends AnyQueryCollection>(query: unknown)
 declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T) => BehaviorSubject<R | null>;
 declare const createQueryCollectionSubject: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => BehaviorSubject<R | null>;
 declare const createQueryCollectionSignal: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => _angular_core.WritableSignal<R | null>;
-declare const extractQuery: <T extends AnyV2Query | AnyLegacyQuery | AnyQueryCollection | null>(v: T) => _ethlete_query.V2Query<any, any, any, any, any, any> | (T & AnyLegacyQuery) | _ethlete_query.LegacyQuery<any, _ethlete_query.LegacyArgumentsOfQueryArgs<any>, `/${string}`, any, any, any, _ethlete_query.Query<any>> | null;
+declare const extractQuery: <T extends AnyV2Query | AnyLegacyQuery | AnyQueryCollection | null>(v: T) => AnyV2Query | AnyLegacyQuery | null;
 declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
 declare const castQueryCreatorTypes: <QC extends AnyV2QueryCreator, Arguments extends V2QueryArgsOf<QC>, Response extends QueryResponseOf<QC>, Store extends QueryStoreOf<QC>, Data extends QueryDataOf<QC>, Route extends V2RouteType<Arguments>, Id extends QueryStoreIdOf<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response | undefined>(config: {
     creator: QC;
@@ -1158,7 +1177,7 @@ declare const castQueryCreatorTypes: <QC extends AnyV2QueryCreator, Arguments ex
 declare const computeQueryMethod: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: V2QueryClient;
-}) => "GET" | "POST" | "OPTIONS" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 declare const computeQueryBody: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: V2QueryClient;
@@ -1179,17 +1198,17 @@ declare const computeQueryQueryParams: (config: {
     client: V2QueryClient;
     args?: BaseArguments;
 }) => object | undefined;
-declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends T extends Paginated<infer X> ? X : never>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
+declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends (T extends Paginated<infer X> ? X : never)>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
     rawResponse: T;
     response: T;
     args: Args;
     entity: Entity;
 }) => {
     response: T & {
-        items: any[];
+        items: unknown[];
     };
     rawResponse: T & {
-        items: any[];
+        items: unknown[];
     };
 } | null;
 
@@ -1297,7 +1316,7 @@ declare class V2QueryClient {
     _updateBaseRoute: (route: string) => void;
 }
 
-declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "OPTIONS" | "HEAD" | "GQL_QUERY";
+declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "HEAD" | "OPTIONS" | "GQL_QUERY";
 declare const v2BuildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;
 
 declare class QueryStore {
@@ -1581,7 +1600,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -1591,7 +1610,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -1879,7 +1898,7 @@ declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQuer
     get instance(): InfinityQueryOf<Q> | null;
     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>;
+    static ngTemplateContextGuard<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>>(_dir: InfinityQueryDirective<Q>, _ctx: unknown): _ctx is InfinityQueryContext<Q>;
     constructor();
     private _setupInfinityQuery;
     loadNextPage(): void;
@@ -1947,7 +1966,7 @@ declare class QueryDirective<Q extends QueryDirectiveType | null> {
     query: _angular_core.InputSignal<Q>;
     cache: _angular_core.InputSignal<boolean>;
     queryState: _angular_core.WritableSignal<_ethlete_query.V2QueryState<QueryDataOf<QueryOf<Q>>> | null>;
-    static ngTemplateContextGuard<Q extends QueryDirectiveType | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryDirectiveContext<Q>;
+    static ngTemplateContextGuard<Q extends QueryDirectiveType | null>(_dir: QueryDirective<Q>, _ctx: unknown): _ctx is QueryDirectiveContext<Q>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
     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>;
@@ -1966,6 +1985,60 @@ declare const queryStateDoesNotContainKeyError: (data: unknown) => QueryError;
 declare const queryStateCannotTransformError: (data: unknown) => QueryError;
 declare const invalidBodyError: (data: unknown) => QueryError;
 
+/** The args accepted by the creator's `prepare()` — includes `mock`/`config` extras. */
+type V2PrepareArgsOf<TCreator extends AnyV2QueryCreator | AnyLegacyQueryCreator> = Parameters<TCreator['prepare']>[0];
+/** Config for {@link validateWithV2Query}. */
+type ValidateWithV2QueryConfig<TCreator extends AnyV2QueryCreator | AnyLegacyQueryCreator, TValue, TPathKind extends PathKind> = {
+    /**
+     * The legacy query creator to run (from `V2QueryClient`'s `post`/`get`, or a
+     * `createLegacyQueryCreator` interop wrapper). A fresh query is prepared and executed for each
+     * validate request. Running it through the client is the point: auth, base route, caching and
+     * error normalization all apply, unlike a raw `httpResource`.
+     */
+    queryCreator: TCreator;
+    /**
+     * Builds the `prepare()` args from the field context. Runs reactively on the field value
+     * (debounced), exactly like `validateAsync`'s `params` — e.g.
+     * `(ctx) => ({ pathParams: { id }, body: { ...ctx.value() } })`.
+     */
+    args: (ctx: FieldContext<TValue, TPathKind>) => V2PrepareArgsOf<TCreator>;
+    /** Debounce before the request runs, in ms. @default 300 */
+    debounce?: number;
+    /** Gate the validation — return `false` to skip the request (e.g. an empty or invalid value). */
+    when?: (ctx: FieldContext<TValue, TPathKind>) => boolean;
+    /**
+     * 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`).
+     * Defaults to `mapViolationsToFormErrors`, resolving each violation's `propertyPath` against the
+     * validated field.
+     */
+    mapViolations?: (violations: FormViolationView[], ctx: FieldContext<TValue, TPathKind>) => TreeValidationResult;
+};
+/**
+ * Binds a query-backed async validator to a signal-forms field, adapting a **legacy v2**
+ * `@ethlete/query` query into what `validateAsync` consumes — the `V2QueryClient` counterpart of
+ * {@link validateWithQuery}, so apps that haven't migrated yet can still validate against the
+ * server. The query runs through the client (bearer auth, base route, caching, Symfony error
+ * normalization), where a raw `httpResource` would fire unauthenticated and bypass the pipeline.
+ *
+ * The query is prepared and executed (debounced) as the field value changes, only after the
+ * field's synchronous validators pass. A `204` / successful response reports no errors; a
+ * `422 FormViolationListView` maps each violation onto its child field by `propertyPath`; a
+ * network / other error degrades to a non-swallowed form-level error.
+ *
+ * Call it from a schema definition, the same place you'd call `validateAsync`:
+ *
+ * ```ts
+ * const schema = schema<OpportunityEmail>((p) => {
+ *   validateWithV2Query(p, {
+ *     queryCreator: postOpportunityEmailValidate, // hubApiClient.post({ ... })
+ *     args: (ctx) => ({ pathParams: { opportunityId }, body: { ...ctx.value() } }),
+ *   });
+ * });
+ * ```
+ */
+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;
+
 type SetupQueryDependenciesOptions = {
     /** The query client tuple from createQueryClient */
     client: AnyCreateQueryClientResult;
@@ -1981,12 +2054,16 @@ type QueryDependencies = {
     client: QueryClient;
     /** The injector of the query */
     injector: EnvironmentInjector;
-    /** The effect scheduler */
-    effectScheduler: _EffectScheduler;
     /** The error handler */
     ngErrorHandler: ErrorHandler;
     /** The http client */
     httpClient: HttpClient;
+    /**
+     * 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.
+     */
+    hostElement: HTMLElement | null;
 };
 declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;
 
@@ -2019,6 +2096,28 @@ type QueryErrorResponse = {
 type QueryErrorResponseItem = {
     message: string;
 };
+declare const isQueryErrorResponse: (error: unknown) => error is QueryErrorResponse;
+/**
+ * Every message carried by an error, flattened into a plain list — one entry for a single error,
+ * one per violation for a list (a form response with several field violations), empty for `null`.
+ *
+ * The single/list split exists because that is how APIs answer; UI almost never wants to branch on
+ * it. Reach for this when rendering, and keep {@link QueryErrorResponse} for anything that needs
+ * the status code or the raw response.
+ *
+ * @example
+ * ```html
+ * @for (message of queryErrorMessages(myQuery.error()); track message) {
+ *   <p class="error">{{ message }}</p>
+ * }
+ * ```
+ */
+declare const queryErrorMessages: (error: QueryErrorResponse | null | undefined) => string[];
+/**
+ * The first message of an error, or `null` when there is none — the single-line counterpart to
+ * {@link queryErrorMessages}, for a toast or a form-field hint.
+ */
+declare const queryErrorMessage: (error: QueryErrorResponse | null | undefined) => string | null;
 declare const createQueryErrorResponse: (error: unknown) => QueryErrorResponse;
 
 type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
@@ -2052,6 +2151,18 @@ type SetupQueryStateOptions<TArgs extends QueryArgs> = {
 type QueryStateSubtle<TArgs extends QueryArgs> = {
     request: WritableSignal<HttpRequest<TArgs> | null>;
     rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
+    /**
+     * Forwards the given request's discrete event stream onto the query-level `events$`.
+     * Called by `queryExecute` whenever a request is (re-)executed.
+     */
+    bindRequestEvents: (request: HttpRequest<TArgs>) => void;
+    /**
+     * 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
+     * of being push-updated by an effect that may not have run yet. Without a `withArgs` feature the
+     * default source returns `null`.
+     */
+    setArgsSource: (source: () => RequestArgs<TArgs> | null) => void;
 };
 type QueryState<TArgs extends QueryArgs> = {
     rawResponse: WritableSignal<RawResponseType<TArgs> | null>;
@@ -2063,6 +2174,14 @@ type QueryState<TArgs extends QueryArgs> = {
     lastTimeExecutedAt: WritableSignal<number | null>;
     lastTriggeredBy: WritableSignal<string | null>;
     executionState: Signal<QueryExecutionState<TArgs> | null>;
+    /**
+     * A discrete, query-level stream of every request event, fed synchronously from the current
+     * request's `events$` at the moment each event occurs. Side-effect features
+     * (success/error/logging) subscribe to this instead of edge-detecting on the shared, resettable
+     * `response`/`error`/`latestHttpEvent` signals — so they cannot miss a transition when the next
+     * execution swaps the underlying request.
+     */
+    events$: Observable<RequestHttpEvent<TArgs>>;
     subtle: QueryStateSubtle<TArgs>;
 };
 type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
@@ -2132,6 +2251,7 @@ declare const QueryFeatureType: {
     readonly WITH_POLLING: "WITH_POLLING";
     readonly WITH_AUTO_REFRESH: "WITH_AUTO_REFRESH";
     readonly WITH_RESPONSE_UPDATE: "WITH_RESPONSE_UPDATE";
+    readonly WITH_PAGE_RESET_ON_ERROR: "WITH_PAGE_RESET_ON_ERROR";
 };
 type QueryFeatureType = (typeof QueryFeatureType)[keyof typeof QueryFeatureType];
 type QueryFeatureContext<TArgs extends QueryArgs> = {
@@ -2241,6 +2361,60 @@ type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
     updater: (data: WithResponseUpdateFeatureFnData<TArgs>) => ResponseType<TArgs> | null;
 };
 declare const withResponseUpdate: <TArgs extends QueryArgs>(options: WithResponseUpdateFeatureOptions<TArgs>) => QueryFeature<TArgs>;
+/**
+ * Whether an error means the requested page is out of range: HTTP `416`, or a
+ * `500` carrying a Symfony/Pagerfanta out-of-range detail (the dev-mode shape).
+ * Exported so it can also be used as the predicate of a `withErrorHandling` handler.
+ */
+declare const isPageOutOfRangeError: (error: QueryErrorResponse) => boolean;
+type WithPageResetOnErrorFeatureOptions = {
+    /**
+     * Which errors trigger the reset.
+     * @default isPageOutOfRangeError (HTTP 416, or a dev-mode 500 Pagerfanta out-of-range error)
+     */
+    when?: (error: QueryErrorResponse) => boolean;
+} & ({
+    /** The writable page signal to reset. */
+    page: WritableSignal<number>;
+    /**
+     * The value to reset the page to.
+     * @default 1
+     */
+    resetTo?: number;
+    reset?: never;
+} | {
+    /**
+     * Called when a matching error occurs. Reset whatever drives the page here —
+     * a signal (`() => page.set(1)`) or a query form (`() => qf.resetFieldToDefault('page')`).
+     */
+    reset: () => void;
+    page?: never;
+    resetTo?: never;
+});
+/**
+ * A query feature that resets the page when the current page becomes out of range
+ * — e.g. after a filter shrinks the result set below the current page. It reacts
+ * to the query's error events and resets the page source; the normal reactive
+ * re-execution then runs with the corrected page.
+ *
+ * Because query args are reactively sourced, this fixes the *source* (a signal or
+ * query form field) rather than patching args directly — so the change sticks.
+ *
+ * @example
+ * // signal-driven page
+ * const users = getUsers(
+ *   withArgs(() => ({ queryParams: { page: page() } })),
+ *   withPageResetOnError({ page }),
+ * );
+ *
+ * @example
+ * // query-form-driven page
+ * const users = getUsers(
+ *   withArgs(() => ({ queryParams: qf.value() })),
+ *   withPageResetOnError({ reset: () => qf.resetFieldToDefault('page') }),
+ * );
+ */
+declare const withPageResetOnError: <TArgs extends QueryArgs>(options: WithPageResetOnErrorFeatureOptions) => QueryFeature<TArgs>;
 
 type RouteType<TArgs extends QueryArgs> = PathParamsType<TArgs> extends {
     [key: string]: unknown;
@@ -2296,6 +2470,14 @@ type BaseQueryCreatorOptions<TArgs extends QueryArgs = QueryArgs> = {
      * @default Client's retryFn or shouldRetryRequest()
      */
     retryFn?: ShouldRetryRequestFn;
+    /**
+     * How long (in ms) this query's cache entry is kept after its last consumer was destroyed.
+     * Overrides the client level `keepUnusedFor`. Use `0` for responses that should never outlive their
+     * consumer (very large payloads, or data that must not be shown stale).
+     *
+     * @default Client's keepUnusedFor (5 minutes)
+     */
+    keepUnusedFor?: number;
     /** Advanced query creator features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
     subtle?: BaseQueryCreatorOptionsSubtle;
 };
@@ -2391,6 +2573,13 @@ type QueryRepositoryEvent = {
     key: QueryKey;
     isSecure: boolean;
     request: HttpRequest<QueryArgs>;
+} | {
+    /**
+     * Every secure entry was torn down at once — a logout. Emitted after the cache is cleared so
+     * secure queries can drop the state they hold themselves; the repository only owns the
+     * requests, not the `response` signal of the query objects bound to them.
+     */
+    type: 'unbind-all-secure';
 };
 type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
     /**
@@ -2424,6 +2613,42 @@ type QueryRepositoryItem<TArgs extends QueryArgs> = {
     /** The request object */
     request: HttpRequest<TArgs>;
 };
+/**
+ * A read-only snapshot of a single cache entry, exposed via {@link QueryRepositorySubtle.cacheEntries}
+ * for devtools inspection. The raw cache `Map` is never exposed.
+ */
+type QueryRepositoryCacheEntry = {
+    /** The cache key of the entry. */
+    key: QueryKey;
+    /** Whether the entry belongs to a secure (authenticated) request. */
+    isSecure: boolean;
+    /** How many consumers currently hold a binding to the entry. */
+    consumerCount: number;
+    /**
+     * Whether the entry has no consumers left and is only being kept around for its
+     * `keepUnusedFor` window. Such an entry is not a leak — it is waiting to be reused by a
+     * consumer that comes back.
+     */
+    isUnused: boolean;
+    /** The underlying HTTP request. */
+    request: HttpRequest<QueryArgs>;
+};
+/**
+ * Advanced repository internals used by the query devtools. **Not part of the general public
+ * contract** — do not build application logic on top of these.
+ */
+type QueryRepositorySubtle = {
+    /** Returns a read-only snapshot of every entry currently held in the cache. */
+    cacheEntries: () => QueryRepositoryCacheEntry[];
+    /** A version counter bumped whenever the cache changes (bind / unbind / unbindAllSecure). */
+    cacheVersion: Signal<number>;
+    /**
+     * Destroys and removes a single cache entry by key, regardless of its consumers. Intended for
+     * devtools cache management — consumers still holding the query will get a fresh request on their
+     * next execution.
+     */
+    evict: (key: QueryKey) => void;
+};
 /**
  * The query repository is responsible for managing all requests and their consumers.
  * It will cache requests if they can be cached and reuse them if they are already cached.
@@ -2436,8 +2661,18 @@ type QueryRepository = {
     unbind: (key: QueryKey | null, consumerDestroyRef: DestroyRef) => boolean;
     /** Removes all secure requests and their consumers */
     unbindAllSecure: () => void;
+    /**
+     * Re-executes every cacheable entry that still has consumers, bypassing the cache and restarting
+     * in-flight requests. Entries kept only for their `keepUnusedFor` window are skipped — nobody is
+     * looking at them, and they revalidate on their own when a consumer binds again.
+     *
+     * @see QueryClient.refreshQueriesInUse
+     */
+    refreshInUse: () => void;
     /** Observable stream of repository events (errors, successes, etc.) */
     events$: Observable<QueryRepositoryEvent>;
+    /** Advanced repository internals used by the query devtools. */
+    subtle: QueryRepositorySubtle;
 };
 /** The key of a query (either a cache key for cacheable requests or a UUID for uncacheable requests) */
 type QueryKey = string;
@@ -2454,7 +2689,22 @@ type QueryRepositoryDependencies = {
 type CreateQueryRepositoryConfig = CreateQueryClientConfigOptions & {
     /** The dependencies of the query repository */
     dependencies: QueryRepositoryDependencies;
+    /**
+     * Whether unused entries may be retained at all. `false` forces `keepUnusedFor` to `0` everywhere,
+     * regardless of client or creator configuration — used to disable retention on the server, where a
+     * per-request injector must not hold response bodies (and a pending timer) for minutes.
+     * @default true
+     */
+    retentionEnabled?: boolean;
 };
+/** @see CreateQueryClientConfigOptions.keepUnusedFor */
+declare const DEFAULT_KEEP_UNUSED_FOR = 300000;
+/**
+ * Hard cap on entries kept without consumers, per client. Retention is opportunistic, so a runaway
+ * count (a search-as-you-type query produces a new cache key per keystroke, and each one goes through
+ * `unbind`) must never grow unbounded — the least recently orphaned entries are dropped first.
+ */
+declare const MAX_UNUSED_ENTRIES = 50;
 declare const createQueryRepository: (config: CreateQueryRepositoryConfig) => QueryRepository;
 
 type CacheAdapterFn = (headers: HttpHeaders) => number | null;
@@ -2466,6 +2716,32 @@ type CreateQueryClientConfigOptions = {
     baseUrl: string;
     /** Configuration for building query strings */
     queryString?: BuildQueryStringConfig;
+    /**
+     * Headers sent with every request of this client — an API token, a tenant id, a preview
+     * credential. Per-query `args.headers` are merged on top and win per header name.
+     *
+     * Pass a function to make them dynamic: it is called on every execution, so reading a signal
+     * inside means later requests pick the new value up on their own.
+     *
+     * Client headers are deliberately **not** part of the cache key: they are the same for every
+     * query of the client, so including them would only ever churn the whole cache at once. That
+     * means already-resolved queries keep their response when the headers change — call
+     * {@link QueryClient.refreshQueriesInUse} to re-run them (the v3 equivalent of v2's
+     * `setDefaultHeaders({ refreshQueriesInUse: true })`).
+     *
+     * @example
+     * const previewToken = signal<string | null>(null);
+     *
+     * export const [provideMyClient, injectMyClient] = createQueryClient({
+     *   name: 'my-api',
+     *   baseUrl: 'https://api.example.com',
+     *   headers: () => {
+     *     const token = previewToken();
+     *     return token ? new HttpHeaders({ 'X-Preview-Token': token }) : new HttpHeaders();
+     *   },
+     * });
+     */
+    headers?: HttpHeaders | (() => HttpHeaders);
     /** The name of the client */
     name: string;
     /**
@@ -2482,9 +2758,42 @@ type CreateQueryClientConfigOptions = {
      * @default shouldRetryRequest()
      */
     retryFn?: ShouldRetryRequestFn;
+    /**
+     * How long (in ms) a cache entry is kept after its last consumer was destroyed.
+     *
+     * Within that window a query that mounts again — a list page reached via browser back navigation,
+     * for instance — binds to the existing entry and renders its previous response immediately while it
+     * revalidates in the background, instead of starting from a loading state. Unlike the header derived
+     * freshness TTL (`cacheAdapter`) this is independent of `cache-control`, so it also applies to
+     * private/authenticated responses.
+     *
+     * Set to `0` to destroy entries as soon as their last consumer goes away. Only entries that
+     * actually hold a response are retained, and at most 50 unused entries are kept per client
+     * (least recently orphaned dropped first). Always `0` on the server.
+     *
+     * Can be overridden per query creator.
+     *
+     * @default 300000 (5 minutes)
+     */
+    keepUnusedFor?: number;
 };
 type QueryClient = {
     repository: QueryRepository;
+    /** The base URL the client was configured with. */
+    baseUrl: string;
+    /**
+     * Re-executes every cacheable request this client currently has consumers for, bypassing the
+     * cache and restarting the ones still in flight.
+     *
+     * The case this exists for is a change to something every request carries but nothing tracks —
+     * typically a client-level header (see {@link CreateQueryClientConfigOptions.headers}). Setting
+     * the new value only affects *subsequent* requests, so anything already resolved keeps data
+     * fetched under the old one until this is called.
+     *
+     * Only GET / HEAD / OPTIONS requests are refreshed: re-firing a mutation nobody asked for would
+     * be a far worse surprise than a stale read.
+     */
+    refreshQueriesInUse: () => void;
 };
 type QueryClientRef = ProviderResult<QueryClient>;
 type AnyCreateQueryClientResult = QueryClientRef;
@@ -2516,6 +2825,13 @@ type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
     dependencies: QueryRepositoryDependencies;
     /** The client options of the request */
     clientOptions?: CreateQueryCreatorOptions;
+    /**
+     * Headers configured on the query client, applied to every request it makes. Per-request
+     * `args.headers` are merged on top and win per header name.
+     *
+     * @see CreateQueryClientConfigOptions.headers
+     */
+    clientHeaders?: HttpHeaders | (() => HttpHeaders);
     /**
      * The cache adapter function to use for the request
      * @default extractExpiresInSeconds()
@@ -2546,9 +2862,20 @@ type HttpRequestLoadingProgressState = {
     remainingTime: number | null;
 };
 type HttpRequest<TArgs extends QueryArgs> = {
-    /** Executes the request */
+    /** The HTTP method of the request. */
+    method: QueryMethod;
+    /** The full URL of the request (base + path + query params). */
+    url: string;
+    /**
+     * Executes the request.
+     *
+     * `force` runs it even when one is already in flight (the in-flight one is cancelled) or the
+     * cached response is still fresh — used by `refreshQueriesInUse` after something outside the
+     * request changed, such as a client-level header.
+     */
     execute: (options?: {
         allowCache?: boolean;
+        force?: boolean;
     }) => boolean;
     /** Destroys the request (cancels it if in progress) */
     destroy: () => boolean;
@@ -2560,8 +2887,25 @@ type HttpRequest<TArgs extends QueryArgs> = {
     response: Signal<ResponseType<TArgs> | null>;
     /** The current event of the request */
     currentEvent: Signal<RequestHttpEvent<TArgs> | null>;
-    /** Whether the request is stale or not aka the cache header has expired */
-    isStale: Signal<boolean>;
+    /**
+     * A discrete stream of every event of this request, emitted synchronously at the moment the
+     * event is processed (including the terminal Response / error event). Unlike the `currentEvent`
+     * signal, this never coalesces or gets reset, so consumers cannot miss a transition. Completes
+     * when the request is destroyed.
+     */
+    events$: Observable<RequestHttpEvent<TArgs>>;
+    /**
+     * Whether the request is stale or not aka the cache header has expired.
+     *
+     * This is a plain getter function (evaluated on each call), not a reactive signal, because
+     * staleness depends on wall-clock time rather than on any tracked signal.
+     */
+    isStale: () => boolean;
+    /**
+     * The timestamp (ms) at which the cached response goes stale, or `null` when the request is not
+     * cacheable / has no freshness window. Exposed for devtools freshness countdowns.
+     */
+    expiresAt: Signal<number | null>;
 };
 /** A custom error event since the Angular http client does not provide a specific event for errors */
 type HttpErrorEvent = {
@@ -2599,6 +2943,19 @@ type PathParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['pathP
 type QueryParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['queryParams'] : never;
 type BodyType<T extends QueryArgs | null> = T extends QueryArgs ? T['body'] : never;
 type RequestArgs<T extends QueryArgs | null> = T extends QueryArgs ? Omit<T, 'response'> : never;
+/**
+ * The empty request-args object, typed to satisfy `RequestArgs<TArgs>` for a query that takes no
+ * arguments — its `QueryArgs` is just `{ response: T }`, so `RequestArgs` resolves to `{}`.
+ *
+ * Only needed in generic code, where `TArgs` is still a type parameter and TS therefore cannot see
+ * that `{}` is the whole of it. Against a concrete query, omit the argument instead: both
+ * `query.execute()` and the auth registry's `execute()` already take none.
+ *
+ * @example
+ * const runAnything = <TArgs extends QueryArgs>(query: Query<TArgs>) =>
+ *   query.execute({ args: emptyQueryArgs<TArgs>() });
+ */
+declare const emptyQueryArgs: <TArgs extends QueryArgs>() => RequestArgs<TArgs>;
 type CreateQueryOptions<TArgs extends QueryArgs> = {
     creator?: CreateQueryCreatorOptions;
     creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
@@ -2641,6 +2998,16 @@ type QuerySubtle<TArgs extends QueryArgs> = {
     destroy: () => void;
     /** Manually sets the response of the query. This will not trigger a new execution of the query. */
     setResponse: (response: ResponseType<TArgs>) => void;
+    /**
+     * Manually forces the loading state of the query. Overridden on the next execution. Intended for
+     * devtools / testing UI states — not for application logic.
+     */
+    setLoading: (loading: HttpRequestLoadingState | null) => void;
+    /**
+     * Manually forces the error state of the query. Overridden on the next execution. Intended for
+     * devtools / testing UI states — not for application logic.
+     */
+    setError: (error: QueryErrorResponse | null) => void;
     /** The currently underlying HTTP request of the query. Will be `null` if the query has never been executed. */
     request: ObservableSignal<HttpRequest<TArgs> | null>;
     /** The destroy reference used to clean up the query when it is no longer needed */
@@ -2712,7 +3079,7 @@ type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ?
 declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<any>) => options is CreateGqlQueryOptions<any>;
 declare const createGqlQuery: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryOptions<TArgs>) => _ethlete_query.Query<TArgs>;
 
-declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
+declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
 declare const shouldAutoExecuteGqlQuery: (method: GqlQueryMethod) => method is "QUERY";
 declare const getQueryFeatureUsage: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<any>) => QueryFeatureFlags;
 declare const applyQueryFeatures: <TArgs extends QueryArgs>(features: QueryFeature<TArgs>[], context: QueryFeatureContext<TArgs>) => void;
@@ -2912,7 +3279,7 @@ type PagedQueryStack<TQuery extends AnyNewQuery, TNormPagination extends Normali
 declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TNormPagination extends NormalizedPagination<unknown>>(options: CreatePagedQueryStackOptions<TArgs, TNormPagination>) => PagedQueryStack<Query<TArgs>, TNormPagination>;
 
 declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
-declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
+declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
 declare const buildQueryCacheKey: (route: string, args: RequestArgs<QueryArgs> | undefined) => string;
 
 type QueryContext = {
@@ -2996,6 +3363,8 @@ declare const QueryRuntimeErrorCode: {
     readonly TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC: 700;
     readonly INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701;
     readonly CIRCULAR_QUERY_DEPENDENCY: 800;
+    readonly QUERY_SEQUENCE_ALREADY_RUNNING: 900;
+    readonly LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT: 950;
 };
 type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
 declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<0>;
@@ -3020,6 +3389,182 @@ declare const gqlDataPropertyMissingInResponse: () => RuntimeError<600>;
 declare const tokensNotAvailableInsideAuthAndExec: () => RuntimeError<700>;
 declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
 declare const circularQueryDependency: () => RuntimeError<800>;
+declare const legacyPrepareWithoutInjectionContext: (creatorName: string | undefined) => RuntimeError<950>;
+declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
+
+/** The last element of a tuple type — the response of the step a `.then()` callback follows. */
+type LastOf<T extends unknown[]> = T extends [...unknown[], infer L] ? L : never;
+/** The current lifecycle phase of a query sequence. */
+type QuerySequenceStatus = 'idle' | 'running' | 'success' | 'error';
+/** The args a sequence step supplies to its query — the same `{ args }` shape `query.execute()` takes. */
+type QuerySequenceStepArgs<TArgs extends QueryArgs> = {
+    args: RequestArgs<TArgs>;
+};
+/**
+ * The outcome of a settled {@link QuerySequence.run}.
+ *
+ * A discriminated union: on success `responses` is the fully-typed tuple of every step's response;
+ * on failure `failedAt` is the zero-based index of the step that errored and `error` is its
+ * normalized {@link QueryErrorResponse}. `snapshots` always holds the settled snapshots of every
+ * step that ran — up to and including the failing one.
+ */
+type QuerySequenceResult<TResponses extends unknown[]> = {
+    ok: true;
+    responses: TResponses;
+    snapshots: AnyQuerySnapshot[];
+} | {
+    ok: false;
+    failedAt: number;
+    error: QueryErrorResponse;
+    snapshots: AnyQuerySnapshot[];
+};
+/**
+ * An imperative waterfall of dependent queries — usually mutations (`POST`/`PUT`/`PATCH`/`DELETE`)
+ * where each call needs the previous call's response.
+ *
+ * Build the chain once (e.g. as a component field) with {@link querySequence} and `.then()`, then
+ * trigger it with {@link run}. Each step runs via `executeUntilSettled`, threading the previous
+ * step's response into the next; the first error aborts the rest. The progress signals mirror
+ * `createQueryStack`, so a template can drive a stepper without manual bookkeeping.
+ */
+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.
+     */
+    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`. */
+    status: Signal<QuerySequenceStatus>;
+    /** `true` while a run is in flight. */
+    running: Signal<boolean>;
+    /** The 1-based index of the in-flight step, or `0` when idle. */
+    currentStep: Signal<number>;
+    /** The static number of steps in the sequence. */
+    total: number;
+    /** The query objects backing each step, in order. Useful for devtools / advanced introspection. */
+    queries: AnyNewQuery[];
+    /** The error of the step that failed, or `null` while running / on success. */
+    error: Signal<QueryErrorResponse | null>;
+    /** The zero-based index of the step that failed, or `null` while running / on success. */
+    failedAt: Signal<number | null>;
+    /** The settled snapshots of every step that has run, grows as the waterfall progresses. */
+    snapshots: Signal<AnyQuerySnapshot[]>;
+    /**
+     * The resolved input args each step was run with, grows as the waterfall progresses. The value at
+     * index `i` is what {@link QuerySequence.then}'s `mapArgs` produced for step `i` at run time.
+     */
+    stepArgs: Signal<unknown[]>;
+    /** The responses of every step that has succeeded, grows as the waterfall progresses. */
+    responses: Signal<Partial<TResponses>>;
+    /**
+     * Runs every step in order, resolving once the waterfall settles.
+     *
+     * Resets the progress signals, then awaits each step in turn — stopping at the first error and
+     * resolving with `{ ok: false, failedAt, error }`, or `{ ok: true, responses }` when all steps
+     * 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.
+     */
+    run: () => Promise<QuerySequenceResult<TResponses>>;
+};
+/**
+ * Starts an imperative waterfall of dependent queries. Chain the remaining steps with `.then()`
+ * and trigger it with `.run()` — see {@link QuerySequence}.
+ *
+ * The seed step's `args` are produced lazily (at `run()` time), so the sequence can safely live as
+ * a component field while still reading current signal values on each run.
+ *
+ * @example
+ * ```ts
+ * readonly checkout = querySequence(this.createOrder, () => ({ args: { body: this.order() } }))
+ *   .then(this.createPayment, (order) => ({ args: { body: { orderId: order.id } } }))
+ *   .then(this.confirmOrder, (payment, [order]) => ({
+ *     args: { pathParams: { paymentId: payment.id }, body: { orderRef: order.id } },
+ *   }));
+ *
+ * async submit() {
+ *   const result = await this.checkout.run();
+ *   if (!result.ok) return this.handle(result.error);
+ *   const [order, payment, confirmation] = result.responses;
+ * }
+ * ```
+ */
+declare const querySequence: <TArgs extends QueryArgs>(query: Query<TArgs>, seedArgs: () => QuerySequenceStepArgs<TArgs>) => QuerySequence<[ResponseType<TArgs>]>;
+
+/** `kind` of a `ValidationError` created from a single server violation. */
+declare const SERVER_VIOLATION_ERROR_KIND = "etServerViolation";
+/** `kind` of the form-level fallback error created when a failed request carries no violations. */
+declare const SERVER_ERROR_KIND = "etServerError";
+/** A signal-forms validation error created from a single server violation. */
+type ServerViolationValidationError = ValidationError.WithOptionalFieldTree & {
+    kind: typeof SERVER_VIOLATION_ERROR_KIND;
+    message: string;
+    /** The violation this error was created from. */
+    violation: FormViolationView;
+};
+/** The form-level fallback error for a failed request that carries no violations. */
+type ServerValidationError = ValidationError.WithOptionalFieldTree & {
+    kind: typeof SERVER_ERROR_KIND;
+    message: string;
+};
+/**
+ * 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.
+ */
+declare const extractFormViolations: (error: unknown) => FormViolationView[];
+type MapViolationsToFormErrorsOptions<TModel> = {
+    /**
+     * The field tree the violation property paths are resolved against — usually the form root
+     * (or the `field` passed to a signal-forms `submit()` action).
+     */
+    fieldTree: FieldTree<TModel>;
+    /**
+     * The failed request's error in any shape `extractFormViolations` accepts: a
+     * `QueryErrorResponse`, a raw `HttpErrorResponse`, an error body, or a violation array.
+     */
+    error: unknown;
+    /**
+     * 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 treat the
+     * violation as unmapped.
+     */
+    rewritePath?: (path: string, violation: FormViolationView) => string | null;
+    /**
+     * Overrides how a violation whose path doesn't resolve to a field is turned into an error.
+     * Return `null` to drop the violation. By default an unmapped violation becomes a form-level
+     * error (no `fieldTree`), which signal forms attaches to the submitted field.
+     */
+    onUnmappedViolation?: (violation: FormViolationView) => ValidationError.WithOptionalFieldTree | null;
+};
+/**
+ * Maps a failed request's violations onto a signal-forms field tree as validation errors —
+ * the bridge between an API's violation list (`@ethlete/types` `FormViolationView`) and
+ * signal forms.
+ *
+ * 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.
+ *
+ * ```ts
+ * await submit(this.form, async (field) => {
+ *   const snapshot = await executeUntilSettled(this.createPost, { args: { body: field().value() } });
+ *   const error = snapshot.error();
+ *
+ *   if (!error) return;
+ *
+ *   return mapViolationsToFormErrors({ fieldTree: field, error });
+ * });
+ * ```
+ */
+declare const mapViolationsToFormErrors: <TModel>(options: MapViolationsToFormErrorsOptions<TModel>) => ValidationError.WithOptionalFieldTree[];
 
 type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
     state: QueryState<TArgs>;
@@ -3028,6 +3573,19 @@ type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
 };
 declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;
 
+/**
+ * Executes the query and resolves once that execution has settled (response or error received).
+ * The returned snapshot is frozen to the awaited execution, so a later execution can't swap the
+ * `response()` / `error()` you read from it.
+ *
+ * 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.
+ */
+declare const executeUntilSettled: <TArgs extends QueryArgs>(query: Query<TArgs>, executeArgs?: QueryExecuteArgs<TArgs>) => Promise<QuerySnapshot<TArgs>>;
+
 type QueryStackSubtle<TCreator extends AnyQueryCreator, TQuery extends AnyNewQuery> = {
     /** Create a new query with the given arguments. You should always prefer the `args` option instead of this. */
     runWithArgs: (args: RequestArgs<QueryArgsOf<TCreator>> | RequestArgs<QueryArgsOf<TCreator>>[] | null) => TQuery | null;
@@ -3170,6 +3728,58 @@ declare const transformPaginatedResponse: <T extends ({
 } | null)[]>(responses: T) => NonNullable<NonNullable<T[0]>["items"]>;
 declare const createQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TDeps extends () => any, TTransform = (ResponseType<TArgs> | null)[]>(options: CreateQueryStackOptions<TCreator, TDeps, TTransform>) => QueryStack<RunQueryCreator<TCreator>, TCreator, TTransform>;
 
+/** Config for {@link validateWithQuery}. */
+type ValidateWithQueryConfig<TCreator extends AnyQueryCreator, TValue, TPathKind extends PathKind> = {
+    /**
+     * The query creator to run (e.g. a secure `createPostQuery` validate route). Like a query stack,
+     * the query is created **once** and re-executes reactively — never per keystroke. Running it
+     * through the query client is the point: auth, base route, caching and error normalization all
+     * apply, unlike a raw `httpResource`.
+     */
+    queryCreator: TCreator;
+    /**
+     * Builds the request args from the field context. Runs reactively on the field value (debounced),
+     * exactly like `validateAsync`'s `params` — e.g.
+     * `(ctx) => ({ pathParams: { id }, body: { ...ctx.value() } })`.
+     */
+    args: (ctx: FieldContext<TValue, TPathKind>) => RequestArgs<QueryArgsOf<TCreator>>;
+    /** Debounce before the request runs, in ms. @default 300 */
+    debounce?: number;
+    /** Gate the validation — return `false` to skip the request (e.g. an empty or invalid value). */
+    when?: (ctx: FieldContext<TValue, TPathKind>) => boolean;
+    /**
+     * 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`).
+     * Defaults to `mapViolationsToFormErrors`, resolving each violation's `propertyPath` against the
+     * validated field.
+     */
+    mapViolations?: (violations: FormViolationView[], ctx: FieldContext<TValue, TPathKind>) => TreeValidationResult;
+};
+/**
+ * Binds a query-backed async validator to a signal-forms field, adapting an `@ethlete/query` v3
+ * query into what `validateAsync` consumes. The query runs through the query client — so bearer
+ * auth, base route, caching and Symfony error normalization all apply — where a raw `httpResource`
+ * would fire unauthenticated and bypass the pipeline.
+ *
+ * On the current v3 `QueryClient` / `createPostQuery` creators; the `validateWithV2Query` twin
+ * covers the legacy `V2QueryClient`. The query is created once and re-executed (debounced) as the
+ * field value changes, only after the field's synchronous validators pass. A `204` / successful
+ * response reports no errors; a `422 FormViolationListView` maps each violation onto its child
+ * field by `propertyPath`; a network / other error degrades to a non-swallowed form-level error.
+ *
+ * Call it from a schema definition, the same place you'd call `validateAsync`:
+ *
+ * ```ts
+ * const schema = schema<OpportunityEmail>((p) => {
+ *   validateWithQuery(p, {
+ *     queryCreator: postOpportunityEmailValidate,
+ *     args: (ctx) => ({ pathParams: { opportunityId }, body: { ...ctx.value() } }),
+ *   });
+ * });
+ * ```
+ */
+declare const validateWithQuery: <TCreator extends AnyQueryCreator, TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, config: ValidateWithQueryConfig<TCreator, TValue, TPathKind>) => void;
+
 type InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs> & {
     authProvider: AnyCreateBearerAuthProviderResult;
 };
@@ -3555,6 +4165,25 @@ declare const withTracking: <TBuilders extends readonly AnyQueryBuilder[]>(confi
 };
 declare const createTrackingFeature: <TBuilders extends readonly AnyQueryBuilder[]>(context: BearerAuthProviderFeatureContext<unknown, TBuilders>, config?: TrackingConfig<TBuilders>) => TrackingFeature<TBuilders>;
 
+type BearerAuthExecutionStateLoading<TType extends string = string> = {
+    type: TType;
+    state: 'loading';
+};
+type BearerAuthExecutionStateSuccess<TType extends string = string> = {
+    type: TType;
+    state: 'success';
+    response: unknown;
+};
+type BearerAuthExecutionStateError<TType extends string = string> = {
+    type: TType;
+    state: 'error';
+    error: QueryErrorResponse;
+};
+type BearerAuthExecutionStateLogout = {
+    type: 'logout';
+    state: 'success';
+};
+type BearerAuthExecutionState<TType extends string = string> = BearerAuthExecutionStateLoading<TType> | BearerAuthExecutionStateSuccess<TType> | BearerAuthExecutionStateError<TType> | BearerAuthExecutionStateLogout;
 declare const BearerAuthFeatureType: {
     readonly PERSISTENT_AUTH: "PERSISTENT_AUTH";
     readonly TOKEN_EXPIRATION_WARNING: "TOKEN_EXPIRATION_WARNING";
@@ -3569,17 +4198,18 @@ type BearerAuthFeature<TBuilders extends readonly AnyQueryBuilder[], TBearerData
 };
 type ExtractQueryKey<T> = T extends AuthQueryBuilder<infer K, any> ? K : T extends TokenRefreshQueryBuilder<infer K, any> ? K : never;
 type ExtractQueryArgs<T> = T extends AuthQueryBuilder<string, infer TArgs> ? TArgs : T extends TokenRefreshQueryBuilder<string, infer TArgs> ? TArgs : never;
+type QueryRegistryEntry<TArgs extends QueryArgs> = {
+    /**
+     * Executes the auth query. `args` may be omitted for a query that takes none — its
+     * `RequestArgs` is `{}`, which generic helper code cannot produce without a cast.
+     */
+    execute: (args?: RequestArgs<TArgs>, options?: RunQueryExecuteOptions) => QuerySnapshot<TArgs>;
+    snapshot: Signal<QuerySnapshot<TArgs> | null>;
+};
 type QueryRegistry<TBuilders extends readonly AnyQueryBuilder[]> = {
-    [K in ExtractQueryKey<TBuilders[number]>]: {
-        execute: (args: RequestArgs<ExtractQueryArgs<Extract<TBuilders[number], {
-            key: K;
-        }>>>, options?: RunQueryExecuteOptions) => QuerySnapshot<ExtractQueryArgs<Extract<TBuilders[number], {
-            key: K;
-        }>>>;
-        snapshot: Signal<QuerySnapshot<ExtractQueryArgs<Extract<TBuilders[number], {
-            key: K;
-        }>>> | null>;
-    };
+    [K in ExtractQueryKey<TBuilders[number]>]: QueryRegistryEntry<ExtractQueryArgs<Extract<TBuilders[number], {
+        key: K;
+    }>>>;
 };
 type HasFeatureType<TFeatures extends readonly unknown[], TType extends BearerAuthFeatureType> = TFeatures extends readonly ((context: any) => any)[] ? Extract<ReturnType<TFeatures[number]>, {
     type: TType;
@@ -3697,6 +4327,24 @@ type BearerAuthProvider<TBuilders extends readonly AnyQueryBuilder[], TFeatures
         key: ExtractQueryKey<TBuilders[number]>;
         snapshot: QuerySnapshot<QueryArgs>;
     } | null>;
+    /**
+     * The current execution state of the auth provider.
+     * Tracks the latest auth operation (login, autoLogin, tokenRefresh, logout, revocation) with its state and payload.
+     */
+    executionState: Signal<BearerAuthExecutionState<ExtractQueryKey<TBuilders[number]> | 'autoLogin' | 'tokenRefresh' | 'logout' | 'revocation'> | null>;
+    /**
+     * Seeds the provider with tokens that were issued outside of it — an SSO/OIDC callback that
+     * arrives with both tokens in the URL, a token handed over by a native shell, a test harness.
+     *
+     * Behaves exactly like a successful auth query: the tokens are applied, `bearerData` /
+     * `isAuthenticated` update, `afterTokenRefresh$` emits so waiting secure queries run, and (unless
+     * disabled) other tabs are synced. Without it the only way in is to execute the refresh query with
+     * the refresh token and throw the access token away.
+     *
+     * Does **not** persist anything by itself — `withPersistentAuth` picks the tokens up through the
+     * same signals it watches for query-issued ones.
+     */
+    setTokens: (accessToken: string, refreshToken: string) => void;
     /**
      * Logout the user (clears all tokens and unbinds secure queries)
      */
@@ -3722,6 +4370,7 @@ type BearerAuthProviderFeatureContext<TBearerData = unknown, TBuilders extends r
         instanceCount: Signal<number>;
     };
     queries: QueryRegistry<TBuilders>;
+    executionState: WritableSignal<BearerAuthExecutionState | null>;
 };
 type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[]> = {
     accessToken: WritableSignal<string | null>;
@@ -3736,7 +4385,102 @@ type BearerAuthProviderQueryContext<TBearerData = unknown, TBuilders extends rea
 declare const createBearerAuthProvider: <TBuilders extends readonly AnyQueryBuilder[], TFeatures extends readonly ((context: BearerAuthProviderFeatureContext<TBearerData, TBuilders>) => unknown)[], TBearerData = unknown>(config: CreateBearerAuthProviderConfig<TBuilders, TFeatures, TBearerData>) => ProviderResult<BearerAuthProvider<TBuilders, TFeatures, TBearerData>>;
 type BearerAuthProviderRef<TBuilders extends readonly AnyQueryBuilder[] = readonly AnyQueryBuilder[], TFeatures extends readonly ((context: BearerAuthProviderFeatureContext<TBearerData, TBuilders>) => unknown)[] = readonly ((context: BearerAuthProviderFeatureContext<unknown, readonly AnyQueryBuilder[]>) => unknown)[], TBearerData = unknown> = ProviderResult<BearerAuthProvider<TBuilders, TFeatures, TBearerData>>;
 type AnyCreateBearerAuthProviderResult = BearerAuthProviderRef<any, any, any>;
-type AnyBearerAuthProvider = NonNullable<ReturnType<AnyCreateBearerAuthProviderResult[1]>>;
+/**
+ * The exact provider type behind a `createBearerAuthProvider` result — query keys, feature registry
+ * and bearer data all preserved.
+ *
+ * Prefer this over {@link AnyBearerAuthProvider} whenever the provider is reachable as a value, e.g.
+ * when passing one into a helper:
+ *
+ * ```ts
+ * export const myApiAuthProviderRef = createBearerAuthProvider({ ... });
+ * export type MyApiAuthProvider = BearerAuthProviderOf<typeof myApiAuthProviderRef>;
+ *
+ * const doLogin = (provider: MyApiAuthProvider) => provider.queries.login({ body: { ... } });
+ * ```
+ */
+type BearerAuthProviderOf<TRef extends AnyCreateBearerAuthProviderResult> = NonNullable<ReturnType<TRef[1]>>;
+type AnyBearerAuthProvider = Omit<NonNullable<ReturnType<AnyCreateBearerAuthProviderResult[1]>>, 'queries'> & {
+    /**
+     * Registry of all configured auth queries.
+     *
+     * Deliberately untyped here: with unknown builders the mapped type degrades to an index
+     * signature, and `noPropertyAccessFromIndexSignature` then rejects `provider.queries.login`
+     * (TS4111) — forcing every call site into bracket access or a hand-written structural contract.
+     * Use {@link BearerAuthProviderOf} where the concrete provider is reachable and the keys survive.
+     */
+    queries: any;
+};
+
+/**
+ * The kind of object a {@link QueryDevtoolsEntry} describes. Part of the devtools contract consumed
+ * by `<et-query-devtools>` — not a general-purpose query API.
+ */
+type QueryDevtoolsEntryKind = 'query' | 'query-stack' | 'paged-query-stack' | 'query-sequence' | 'auth-provider' | 'ws-client';
+/**
+ * Descriptive, mostly-static metadata about a registered devtools entry. The live, reactive state
+ * is read from the entry's {@link QueryDevtoolsEntry.handle} instead.
+ */
+type QueryDevtoolsEntryMeta = {
+    /** Display name of the owning query client, where known. */
+    clientName?: string;
+    /** Base URL of the owning query client, where known. */
+    clientBaseUrl?: string;
+    /** Human readable display name (e.g. an auth provider or web socket client name). */
+    name?: string;
+    /** The connection URL, for web socket clients. */
+    url?: string;
+    /** The GraphQL document string, for GraphQL queries. */
+    gqlQuery?: string;
+    /** Stringified route with path params rendered as `:param`, for queries. */
+    route?: string;
+    /** Human readable HTTP/GQL method, for queries (e.g. `GET`, `GQL QUERY`). */
+    method?: string;
+    /** The feature types applied at creation, for queries. */
+    featureTypes?: QueryFeatureType[];
+    /** The query config passed at creation, for queries. */
+    queryConfig?: QueryConfig;
+    /** The creator options passed at creation, for queries. */
+    creator?: CreateQueryCreatorOptions;
+    /** The owning client's repository, where known (queries and auth providers). */
+    repository?: QueryRepository;
+    /**
+     * The DOM element of the component/directive that created a query, when available. Used by the
+     * devtools "inspect" tool to map a query back to its place in the live UI.
+     */
+    element?: HTMLElement | null;
+};
+/**
+ * A single entry in the {@link queryDevtoolsEntries} registry. The `handle` is the live object
+ * (query, stack, sequence or auth provider) so its signals stay reactive when read by the UI.
+ */
+type QueryDevtoolsEntry = {
+    id: string;
+    kind: QueryDevtoolsEntryKind;
+    meta: QueryDevtoolsEntryMeta;
+    handle: unknown;
+    createdAt: number;
+};
+/**
+ * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
+ */
+declare const queryDevtoolsEntries: Signal<QueryDevtoolsEntry[]>;
+/**
+ * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
+ * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
+ * appear in the `<et-query-devtools>` panel.
+ *
+ * When omitted, all devtools instrumentation is a no-op — no references are retained and there is no
+ * runtime overhead — so it is safe to leave out of production builds.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideQueryDevtools()],
+ * });
+ * ```
+ */
+declare const provideQueryDevtools: () => EnvironmentProviders;
 
 type TransformedGqlQuery = {
     query: string;
@@ -3827,6 +4571,283 @@ declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageEnPipe, "parseHttpErrorCodeToMessageEn", true>;
 }
 
+/**
+ * The internal, fully-resolved definition of a single query-form field.
+ *
+ * Produced by the field creators (`queryField()`, `searchQueryField()`, …) and
+ * consumed by `createQueryForm()`. `T` is the field's value type and always
+ * includes `null` (a field can be cleared).
+ */
+type QueryFieldDef<T> = {
+    /**
+     * The default value. When the field equals this value it is elided from the
+     * URL (unless `appendDefaultValueToUrl` is set) and ignored by the filter
+     * count. A function is evaluated lazily every time the default is needed.
+     */
+    readonly defaultValue: T | (() => T);
+    /** Debounce in milliseconds before a change is committed (emitted + written to the URL). */
+    readonly debounce?: number;
+    /**
+     * Skip the debounce when the new value is falsy. Useful for search fields so
+     * that clearing the input applies immediately while typing stays debounced.
+     *
+     * @default false
+     */
+    readonly disableDebounceIfFalsy?: boolean;
+    /**
+     * Write the field's value to the URL. A field is never written while it holds
+     * its default value unless `appendDefaultValueToUrl` is set.
+     *
+     * @default true
+     */
+    readonly appendToUrl?: boolean;
+    /**
+     * Write the field to the URL even when it holds its default value. Ignored
+     * when `appendToUrl` is `false`.
+     *
+     * @default false
+     */
+    readonly appendDefaultValueToUrl?: boolean;
+    /**
+     * Reset this field to its default whenever one of the listed sibling fields
+     * changes — e.g. a `page` field is reset by `['search', 'limit']`.
+     */
+    readonly isResetBy?: readonly string[];
+    /**
+     * Exclude this field from `activeFilterCount`. The common pagination/sort/search
+     * keys are excluded automatically (see `IGNORED_FILTER_COUNT_FIELDS`).
+     *
+     * @default false
+     */
+    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.
+     *
+     * @default false
+     */
+    readonly skipAutoTransform?: boolean;
+    /** Transform a raw URL query-param value into the field's value type. */
+    readonly queryParamToValue?: (raw: unknown) => T;
+    /** Transform the field's value into a raw URL query-param value. */
+    readonly valueToQueryParam?: (value: T) => unknown;
+};
+/**
+ * Options accepted by a field creator. Everything is optional; `isResetBy`
+ * accepts a single key or a list for convenience.
+ */
+type QueryFieldConfig<T> = Partial<Omit<QueryFieldDef<T>, 'isResetBy'>> & {
+    readonly isResetBy?: string | readonly string[];
+};
+/** Extracts a field definition's value type. */
+type QueryFieldValue<F> = F extends QueryFieldDef<infer T> ? T : never;
+/** A map of field name → field definition, as passed to `createQueryForm({ fields })`. */
+type QueryFormFields = Record<string, QueryFieldDef<unknown>>;
+/** The value shape of a query form — one entry per field. */
+type QueryFormModel<TFields extends QueryFormFields> = {
+    [K in keyof TFields]: QueryFieldValue<TFields[K]>;
+};
+/** A committed change: the value before and after a commit. */
+type QueryFormChange<TFields extends QueryFormFields> = {
+    readonly previousValue: QueryFormModel<TFields> | null;
+    readonly currentValue: QueryFormModel<TFields>;
+};
+/**
+ * Options passed to `observe()`. Named distinctly from the legacy
+ * `QueryFormObserveOptions` to keep both APIs' barrel exports intact.
+ */
+type QueryFormSignalsObserveOptions = {
+    /**
+     * Sync the committed value to the URL query params.
+     * @default true
+     */
+    readonly writeToQueryParams?: boolean;
+    /**
+     * Apply URL → form changes on navigation (back/forward, external links).
+     * @default true
+     */
+    readonly syncOnNavigation?: boolean;
+    /**
+     * Replace the current history entry instead of pushing a new one.
+     * @default false
+     */
+    readonly replaceUrl?: boolean;
+};
+/**
+ * Options for a single programmatic write (`setValue`/`patchValue`/reset).
+ *
+ * Named distinctly from the legacy reactive-forms `QueryFormWriteOptions` (which
+ * also carried the RxJS-only `onlySelf`/`emitEvent`) — the signals variant only
+ * needs `skipResets`.
+ */
+type QueryFormSignalsWriteOptions = {
+    /**
+     * Skip the `isResetBy` graph for this write, so dependent fields keep their
+     * current value instead of resetting to default.
+     * @default false
+     */
+    readonly skipResets?: boolean;
+};
+
+/**
+ * Fields excluded from `activeFilterCount` by default — pagination, sorting and
+ * search are navigation state, not filters.
+ */
+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`).
+ */
+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. */
+    readonly value: Signal<QueryFormModel<TFields>>;
+    /** The number of active (non-default) filters in the branch. */
+    readonly activeFilterCount: Signal<number>;
+    setValue(value: QueryFormModel<TFields>): void;
+    patchValue(value: Partial<QueryFormModel<TFields>>): void;
+    resetFieldToDefault(key: keyof QueryFormModel<TFields>): void;
+    resetAllFieldsToDefault(): void;
+};
+type CreateQueryFormConfig<TFields extends QueryFormFields> = {
+    readonly fields: TFields;
+    /**
+     * A prefix for every query-param key, so multiple query forms can coexist on
+     * one route (e.g. prefix `'users'` maps the `page` field to `users-page`).
+     * A function is evaluated every time a key is built.
+     */
+    readonly queryParamPrefix?: string | (() => string);
+};
+/**
+ * A signals-first query form: binds on-screen controls to typed fields, keeps a
+ * debounced committed value, syncs to the URL query params, and resets dependent
+ * fields via the `isResetBy` graph — all as signals.
+ *
+ * @example
+ * const qf = createQueryForm({
+ *   fields: {
+ *     search: searchQueryField(),
+ *     sort: sortQueryField(),
+ *     page: queryField<number>({ defaultValue: 1, isResetBy: ['search', 'sort'] }),
+ *   },
+ * }).observe();
+ * // template: <input etInput [formField]="qf.fields.search" />
+ */
+declare class QueryFormSignals<TFields extends QueryFormFields> {
+    private readonly _router;
+    private readonly _route;
+    private readonly _injector;
+    private readonly _fields;
+    private readonly _prefix;
+    private readonly _defaults;
+    /** Live field values (updated immediately by bound controls). */
+    private readonly _model;
+    /** The committed (debounced) value that drives `value`, the URL and the filter count. */
+    private readonly _committed;
+    private readonly _previous;
+    private readonly _observing;
+    private readonly _queryParamChanges;
+    private _observeOptions;
+    private _pendingTimer;
+    private _skipNextResets;
+    /**
+     * The bindable signal-forms field tree — bind a field with `[formField]`, e.g.
+     * `<input etInput [formField]="qf.fields.search" />`.
+     */
+    readonly fields: FieldTree<QueryFormModel<TFields>>;
+    /** The committed value of the form. */
+    readonly value: Signal<QueryFormModel<TFields>>;
+    /** The committed value before the most recent change. */
+    readonly previousValue: Signal<QueryFormModel<TFields> | null>;
+    /** The previous/current value pair of the most recent committed change. */
+    readonly changes: Signal<QueryFormChange<TFields>>;
+    /**
+     * The number of active filters. Excludes the pagination/sort/search keys and
+     * any field created with `skipInFilterCount`.
+     */
+    readonly activeFilterCount: Signal<number>;
+    /** The default value of the whole form. */
+    readonly defaultValue: QueryFormModel<TFields>;
+    constructor(config: CreateQueryFormConfig<TFields>);
+    observe(options?: QueryFormSignalsObserveOptions): this;
+    unobserve(): void;
+    setValue(value: QueryFormModel<TFields>, options?: QueryFormSignalsWriteOptions): void;
+    patchValue(value: Partial<QueryFormModel<TFields>>, options?: QueryFormSignalsWriteOptions): void;
+    resetFieldToDefault(key: keyof QueryFormModel<TFields>, options?: QueryFormSignalsWriteOptions): void;
+    resetFieldsToDefault(keys: (keyof QueryFormModel<TFields>)[], options?: QueryFormSignalsWriteOptions): void;
+    resetAllFieldsToDefault(options?: QueryFormSignalsWriteOptions & {
+        skipFields?: (keyof QueryFormModel<TFields>)[];
+    }): void;
+    /** Create a detached editor over the same fields, seeded from the current committed value. */
+    branch(): QueryFormBranch<TFields>;
+    private _onLiveChange;
+    /** Shortest-debounce-wins; `null` means commit immediately. */
+    private _resolveDebounce;
+    private _flush;
+    private _applyResets;
+    private _applyFromUrl;
+    private _commitFromUrl;
+    private _deserialize;
+    private _writeToUrl;
+    private _paramKey;
+    private _clearTimer;
+    private _cleanup;
+}
+/**
+ * Create a {@link QueryFormSignals}. Call `.observe()` to start syncing with the
+ * URL. Must be called in an injection context.
+ */
+declare const createQueryForm: <TFields extends QueryFormFields>(config: CreateQueryFormConfig<TFields>) => QueryFormSignals<TFields>;
+
+/**
+ * A generic query-form field. Defaults to `null` and, unless a transform is
+ * given, relies on the auto-coercion when reading back from the URL.
+ *
+ * @example
+ * queryField<number>({ defaultValue: 1, isResetBy: ['search'] })
+ */
+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`).
+ */
+declare const searchQueryField: (config?: QueryFieldConfig<string | null>) => QueryFieldDef<string | null>;
+/**
+ * A sort field serialized as `"active:direction"` (e.g. `"name:asc"`). Matches
+ * the wire format the table system's URL adapter uses, so the two interoperate.
+ */
+declare const sortQueryField: (config?: QueryFieldConfig<Sort | null>) => QueryFieldDef<Sort | null>;
+/** A field holding a list of strings. */
+declare const stringArrayQueryField: (config?: QueryFieldConfig<string[] | null>) => QueryFieldDef<string[] | null>;
+/** A field holding a list of numbers. */
+declare const numberArrayQueryField: (config?: QueryFieldConfig<number[] | null>) => QueryFieldDef<number[] | null>;
+/** A field holding a list of booleans. */
+declare const booleanArrayQueryField: (config?: QueryFieldConfig<boolean[] | null>) => QueryFieldDef<boolean[] | null>;
+/** A single date field (expects an ISO/`Date`-parseable string in the URL). */
+declare const dateQueryField: (config?: QueryFieldConfig<Date | null>) => QueryFieldDef<Date | null>;
+/** A field holding a list of dates. */
+declare const dateArrayQueryField: (config?: QueryFieldConfig<Date[] | null>) => QueryFieldDef<Date[] | null>;
+
+/** A single message captured for the devtools web socket inspector. */
+type WebSocketDevtoolsMessage = {
+    id: number;
+    timestamp: number;
+    room: string;
+    event: string;
+    data: unknown;
+};
+/**
+ * The live handle a web socket client registers with the devtools. Read by the `<et-query-devtools>`
+ * Sockets tab. Not part of the general public contract.
+ */
+type WebSocketDevtoolsHandle = {
+    connected: Signal<boolean>;
+    rooms: Signal<string[]>;
+    messages: Signal<WebSocketDevtoolsMessage[]>;
+};
 type CreateWebSocketClientTransport = 'polling' | 'websocket' | 'webtransport';
 type CreateWebSocketClientConfigOptions = {
     /** A unique name for the client */
@@ -3870,5 +4891,5 @@ type WebSocketClientResult<TMessageData extends SocketMessageView = SocketMessag
 type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientResult<TMessageData>;
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, extractExpiresInSeconds, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryExecute, queryFeatureUsedMultipleTimes, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthFeature, BearerAuthProvider, BearerAuthProviderFeatureContext, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, 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, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, Method, ObservableSignal, OptionalQueryFieldOptions, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientRef, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldOptions, QueryFilterConfig, QueryFormGroup, QueryFormGroupControls, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryKey, QueryMethod, QueryMockConfig, QueryOf, QueryParams, QueryParamsType, QueryPrepareFn, QueryRegistry, QueryRepository, QueryRepositoryDependencies, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRequestOptions, QueryResponseOf, QueryRouteOf, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QueryTrigger, RawResponseType, ReadonlyQuery, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, 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, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, WebSocketClient, WebSocketClientResult, WebSocketClientSubtle, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DateArrayQueryField, DateQueryField, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryForm, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, searchQueryField, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthFeature, BearerAuthProvider, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryFormConfig, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, 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, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientRef, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryKey, QueryMethod, QueryMockConfig, QueryOf, QueryParams, QueryParamsType, QueryPrepareFn, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QueryTrigger, RawResponseType, ReadonlyQuery, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientResult, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };