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

package/types/ethlete-query.d.ts

@@ -545,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;
@@ -554,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;
@@ -646,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 = {
     /**
@@ -1047,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']>;
@@ -1149,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;
@@ -2079,6 +2097,27 @@ 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> = {
@@ -2212,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> = {
@@ -2321,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;
@@ -2376,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;
 };
@@ -2471,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> = {
     /**
@@ -2515,6 +2624,12 @@ type QueryRepositoryCacheEntry = {
     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>;
 };
@@ -2546,6 +2661,14 @@ 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. */
@@ -2566,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;
@@ -2578,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;
     /**
@@ -2594,11 +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;
@@ -2630,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()
@@ -2664,9 +2866,16 @@ type HttpRequest<TArgs extends QueryArgs> = {
     method: QueryMethod;
     /** The full URL of the request (base + path + query params). */
     url: string;
-    /** Executes the request */
+    /**
+     * 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;
@@ -2734,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>;
@@ -3142,6 +3364,7 @@ declare const QueryRuntimeErrorCode: {
     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>;
@@ -3166,6 +3389,7 @@ 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. */
@@ -3974,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;
@@ -4107,6 +4332,19 @@ type BearerAuthProvider<TBuilders extends readonly AnyQueryBuilder[], TFeatures
      * 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)
      */
@@ -4147,7 +4385,32 @@ 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
@@ -4308,6 +4571,266 @@ 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;
@@ -4368,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, 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, 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, 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, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryExecute, queryFeatureUsedMultipleTimes, querySequence, querySequenceAlreadyRunning, 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, validateWithQuery, validateWithV2Query, 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, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, 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, 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, QueryFieldOptions, QueryFilterConfig, QueryFormGroup, QueryFormGroupControls, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryKey, QueryMethod, QueryMockConfig, QueryOf, QueryParams, QueryParamsType, QueryPrepareFn, QueryRegistry, 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, 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 };