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

package/fesm2022/ethlete-query.mjs

@@ -1,14 +1,14 @@
 import * as i0 from '@angular/core';
-import { signal, isDevMode, makeEnvironmentProviders, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, resource, DOCUMENT, NgZone } from '@angular/core';
+import { signal, isDevMode, makeEnvironmentProviders, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, resource, PLATFORM_ID, DOCUMENT, NgZone } from '@angular/core';
 import { createStaticProvider, RuntimeError, clamp, createDestroy, computedTillTruthy, getCookie, setCookie, deleteCookie, createProvider, nextFrame, randomId, createRootProvider, isObject, injectRoute, getDomain, injectQueryParamChanges, injectQueryParams, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { filter, Subject, Subscription, Observable, tap, retry, throwError, timer, catchError, takeUntil, startWith, pairwise, switchMap, of, BehaviorSubject, fromEvent, take, ReplaySubject, map, shareReplay, interval, skip, takeWhile, combineLatest, EMPTY, withLatestFrom, debounceTime, firstValueFrom, merge, throttleTime } from 'rxjs';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
-import { NgClass, AsyncPipe, JsonPipe } from '@angular/common';
+import { NgClass, AsyncPipe, JsonPipe, isPlatformBrowser } from '@angular/common';
 import * as i1 from '@angular/forms';
 import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
-import { validateAsync } from '@angular/forms/signals';
+import { validateAsync, form } from '@angular/forms/signals';
 import { Router, ActivatedRoute } from '@angular/router';
 import { io } from 'socket.io-client';
 
@@ -318,6 +318,8 @@ const QueryRuntimeErrorCode = {
     CIRCULAR_QUERY_DEPENDENCY: 800,
     // Query Sequence
     QUERY_SEQUENCE_ALREADY_RUNNING: 900,
+    // Legacy interop
+    LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT: 950,
 };
 const queryFeatureUsedMultipleTimes = (type) => {
     return new RuntimeError(QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES, `The query feature "${type}()" was used multiple times.`);
@@ -386,10 +388,53 @@ const invalidStateInsideSecureExecuteFactory = () => {
 const circularQueryDependency = () => {
     return new RuntimeError(QueryRuntimeErrorCode.CIRCULAR_QUERY_DEPENDENCY, `Query was executed more than 5 times in less than 100ms. This is usually a sign of a circular dependency.`);
 };
+const legacyPrepareWithoutInjectionContext = (creatorName) => {
+    const label = creatorName ? `"${creatorName}"` : 'A legacy query creator';
+    return new RuntimeError(QueryRuntimeErrorCode.LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT, `${label}.prepare() was called outside of an injection context. Unlike the v2 client, the legacy interop layer needs an injector to build the underlying query.\n\n` +
+        `Capture one where a context does exist (field initializer, constructor) and pass it along:\n\n` +
+        `  private injector = inject(Injector);\n` +
+        `  search = (term: string) => myQuery.prepare({ queryParams: { term }, injector: this.injector });\n\n` +
+        `Prefer an injector that outlives the call site. A component injector passed from a callback that can still fire after the component is gone leaves prepare() with a destroyed injector, which returns an inert query instead of executing.`);
+};
 const querySequenceAlreadyRunning = () => {
     return new RuntimeError(QueryRuntimeErrorCode.QUERY_SEQUENCE_ALREADY_RUNNING, `run() was called on a query sequence that is already running. Wait for the current run to settle before starting another.`);
 };
 
+const isClassValidatorError = (error) => {
+    return typeof error === 'object' && error !== null && 'statusCode' in error && 'message' in error && 'error' in error;
+};
+const isSymfonyError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const symfonyError = error;
+    return (symfonyError.class !== undefined &&
+        symfonyError.detail !== undefined &&
+        symfonyError.status !== undefined &&
+        symfonyError.title !== undefined &&
+        symfonyError.trace !== undefined &&
+        symfonyError.type !== undefined);
+};
+const isSymfonyPagerfantaOutOfRangeError = (error) => {
+    if (!isSymfonyError(error)) {
+        return false;
+    }
+    return error.class.startsWith('Pagerfanta') && error.class.endsWith('OutOfRangeCurrentPageException');
+};
+const isSymfonyFormViolationListError = (error) => {
+    return typeof error === 'object' && error !== null && 'violations' in error;
+};
+const isSymfonyListError = (error) => {
+    return (!!error &&
+        typeof error === 'object' &&
+        Array.isArray(error) &&
+        !!error.length &&
+        typeof error[0] === 'object' &&
+        'message' in error[0] &&
+        'propertyPath' in error[0] &&
+        'invalidValue' in error[0]);
+};
+
 /**
  * Returning this inside a withArgs feature will reset the query args to null.
  * This will also pause polling and auto refresh until new args are set.
@@ -413,6 +458,7 @@ const QueryFeatureType = {
     WITH_POLLING: 'WITH_POLLING',
     WITH_AUTO_REFRESH: 'WITH_AUTO_REFRESH',
     WITH_RESPONSE_UPDATE: 'WITH_RESPONSE_UPDATE',
+    WITH_PAGE_RESET_ON_ERROR: 'WITH_PAGE_RESET_ON_ERROR',
 };
 const createQueryFeature = (config) => {
     return config;
@@ -578,6 +624,59 @@ const withResponseUpdate = (options) => {
         },
     });
 };
+/**
+ * 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.
+ */
+const isPageOutOfRangeError = (error) => {
+    if (error.code === 416)
+        return true;
+    return error.code === 500 && isSymfonyPagerfantaOutOfRangeError(error.raw.error);
+};
+/**
+ * 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') }),
+ * );
+ */
+const withPageResetOnError = (options) => {
+    const matches = options.when ?? isPageOutOfRangeError;
+    return createQueryFeature({
+        type: QueryFeatureType.WITH_PAGE_RESET_ON_ERROR,
+        fn: (context) => {
+            context.state.events$
+                .pipe(filter((event) => event.type === 'error'), takeUntilDestroyed(context.deps.destroyRef))
+                .subscribe((event) => {
+                if (!matches(event.error))
+                    return;
+                if (options.reset) {
+                    options.reset();
+                }
+                else {
+                    options.page.set(options.resetTo ?? 1);
+                }
+            });
+        },
+    });
+};
 
 const setupQueryState = (options) => {
     const request = signal(null, /* @ts-ignore */
@@ -963,6 +1062,19 @@ const createExecuteFn = (executeOptions) => {
 };
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * 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>() });
+ */
+const emptyQueryArgs = () => ({});
 const createQuery = (options) => createBaseQuery({
     creator: options.creator,
     creatorInternals: options.creatorInternals,
@@ -1012,41 +1124,6 @@ const createBaseQueryCreator = (config) => {
     return queryCreator;
 };
 
-const isClassValidatorError = (error) => {
-    return typeof error === 'object' && error !== null && 'statusCode' in error && 'message' in error && 'error' in error;
-};
-const isSymfonyError = (error) => {
-    if (!error || typeof error !== 'object') {
-        return false;
-    }
-    const symfonyError = error;
-    return (symfonyError.class !== undefined &&
-        symfonyError.detail !== undefined &&
-        symfonyError.status !== undefined &&
-        symfonyError.title !== undefined &&
-        symfonyError.trace !== undefined &&
-        symfonyError.type !== undefined);
-};
-const isSymfonyPagerfantaOutOfRangeError = (error) => {
-    if (!isSymfonyError(error)) {
-        return false;
-    }
-    return error.class.startsWith('Pagerfanta') && error.class.endsWith('OutOfRangeCurrentPageException');
-};
-const isSymfonyFormViolationListError = (error) => {
-    return typeof error === 'object' && error !== null && 'violations' in error;
-};
-const isSymfonyListError = (error) => {
-    return (!!error &&
-        typeof error === 'object' &&
-        Array.isArray(error) &&
-        !!error.length &&
-        typeof error[0] === 'object' &&
-        'message' in error[0] &&
-        'propertyPath' in error[0] &&
-        'invalidValue' in error[0]);
-};
-
 const buildErrorMessage = (code, message) => `[@ethlete\\query:${code}] ${message}`;
 class QueryError extends Error {
     constructor(code, message, data) {
@@ -1647,6 +1724,31 @@ const shouldRetryRequest = (options) => {
 const isQueryErrorResponse = (error) => {
     return typeof error === 'object' && error !== null && 'raw' in error && 'retryState' in error && 'isList' in error;
 };
+/**
+ * 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>
+ * }
+ * ```
+ */
+const queryErrorMessages = (error) => {
+    if (!error)
+        return [];
+    return error.isList ? error.errors.map((item) => item.message) : [error.error.message];
+};
+/**
+ * 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.
+ */
+const queryErrorMessage = (error) => queryErrorMessages(error)[0] ?? null;
 const createQueryErrorResponse = (error) => {
     let err = error instanceof HttpErrorResponse ? error : null;
     if (!err) {
@@ -1739,8 +1841,21 @@ const createHttpRequest = (options) => {
         const expiresInTs = expiresIn();
         return expiresInTs === null || expiresInTs < Date.now();
     };
+    // Resolved per execution rather than once at creation, so a client whose headers are a function
+    // reading a signal (a preview token, a tenant id) sees the current value on every re-run.
+    const resolveHeaders = () => {
+        const clientHeaders = typeof options.clientHeaders === 'function' ? options.clientHeaders() : options.clientHeaders;
+        const argHeaders = typeof args?.headers === 'function' ? args.headers() : args?.headers;
+        if (!clientHeaders)
+            return argHeaders;
+        if (!argHeaders)
+            return clientHeaders;
+        // `set` replaces every value of that name, so a per-request header fully overrides the
+        // client-level one instead of being appended next to it.
+        return argHeaders.keys().reduce((merged, key) => merged.set(key, argHeaders.getAll(key) ?? []), clientHeaders);
+    };
     const createStream = () => {
-        const headers = typeof args?.headers === 'function' ? args.headers() : args?.headers;
+        const headers = resolveHeaders();
         return dependencies.httpClient
             .request(options.method, options.fullPath, {
             observe: 'events',
@@ -1766,7 +1881,7 @@ const createHttpRequest = (options) => {
         }));
     };
     const execute = (options) => {
-        if (loading() || (!isStale() && options?.allowCache)) {
+        if (!options?.force && (loading() || (!isStale() && options?.allowCache))) {
             // Do not execute if there is already a request in progress or caching is allowed
             return false;
         }
@@ -2879,6 +2994,12 @@ const createSecureExecuteFactory = (options) => {
             executeOptions: { deps: options.deps, state: options.state },
         });
     };
+    // A logout tears down the secure entries in the repository, but the query object holding one keeps
+    // its own `response`/`error` signals — so without this a component still mounted after logout goes
+    // on rendering the previous user's data until something calls `reset()` by hand.
+    options.deps.client.repository.events$
+        .pipe(filter((event) => event.type === 'unbind-all-secure'), takeUntilDestroyed(options.deps.destroyRef))
+        .subscribe(() => reset());
     const error = (query) => {
         const state = options.state;
         state.error.set(query.error());
@@ -3196,10 +3317,18 @@ class LegacyQuery {
     get _isInMockMode() {
         return false;
     }
-    constructor(newQuery, _arguments, entity) {
+    constructor(newQuery, _arguments, entity, 
+    /**
+     * Wraps an inert query — see `createInertQuery`. Skips everything that needs a live injector,
+     * so the wrapper is safe to build during teardown.
+     *
+     * @internal
+     */
+    _isInert = false) {
         this.newQuery = newQuery;
         this._arguments = _arguments;
         this.entity = entity;
+        this._isInert = _isInert;
         /**
          * @internal
          */
@@ -3208,9 +3337,31 @@ class LegacyQuery {
          * @internal
          */
         this._currentPollConfig = null;
+        /**
+         * `null` for an inert query — there is no live injector to own an effect.
+         *
+         * @internal
+         */
+        this.storeSyncEffect = null;
+        /**
+         * @internal
+         */
+        this._dependents = {};
+        /**
+         * @internal
+         */
+        this._dependentsChanged$ = new ReplaySubject();
         /**
          * @internal
          */
+        this._isPollingPaused = false;
+        this._isDestroyed = false;
+        if (this._isInert) {
+            this.state$ = of(transformExecStateToQueryState(null));
+            this._isDestroyed = true;
+            return;
+        }
+        this.state$ = toObservable(this.newQuery.executionState, { injector: this.newQuery.subtle.injector }).pipe(map((execState) => transformExecStateToQueryState(execState)), switchMap((s) => this._transformState(s)), shareReplay({ bufferSize: 1, refCount: true }));
         this.storeSyncEffect = effect(() => {
             const res = this.newQuery.response();
             untracked(() => {
@@ -3226,27 +3377,28 @@ class LegacyQuery {
             });
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "storeSyncEffect" }] : /* istanbul ignore next */ []));
-        /**
-         * @internal
-         */
-        this._dependents = {};
-        /**
-         * @internal
-         */
-        this._dependentsChanged$ = new ReplaySubject();
-        /**
-         * @internal
-         */
-        this._isPollingPaused = false;
-        this.state$ = toObservable(this.newQuery.executionState, { injector: this.newQuery.subtle.injector }).pipe(map((execState) => transformExecStateToQueryState(execState)), switchMap((s) => this._transformState(s)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.newQuery.subtle.destroyRef.onDestroy(() => this.destroy());
+        // Tear down only what this wrapper owns. The underlying query is already being destroyed when this fires, so
+        // destroying it again would call `R3Injector.destroy()` on an injector that is mid-teardown, which throws
+        // NG0205 ("Injector has already been destroyed") from inside the view's cleanup phase.
+        this.newQuery.subtle.destroyRef.onDestroy(() => this._teardown());
     }
-    destroy() {
+    _teardown() {
+        if (this._isDestroyed) {
+            return;
+        }
+        this._isDestroyed = true;
         this._pollingSubscription?.unsubscribe();
         this._pollingSubscription = null;
         this._dependentsChanged$.complete();
+        this.storeSyncEffect?.destroy();
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            return;
+        }
+        this._teardown();
+        // Re-enters `_teardown` through the query's `destroyRef`, which the `_isDestroyed` guard absorbs.
         this.newQuery.subtle.destroy();
-        this.storeSyncEffect.destroy();
     }
     execute(options = {}) {
         untracked(() => this.newQuery.execute({ args: this._arguments, options: { allowCache: options.skipCache !== true } }));
@@ -3260,7 +3412,8 @@ class LegacyQuery {
         return this;
     }
     poll(config) {
-        if (this._pollingSubscription) {
+        // An inert or already destroyed query has nothing to poll, and the interval would outlive it.
+        if (this._pollingSubscription || this._isDestroyed) {
             return this;
         }
         this._currentPollConfig = config;
@@ -3345,11 +3498,89 @@ class LegacyQuery {
     }
 }
 
+/**
+ * A query that never executes and never leaves its initial state.
+ *
+ * `LegacyQueryCreator.prepare()` hands one back when the injector it was given is already destroyed
+ * — the shape v2 call sites still fire into during teardown (a debounced search resolving after the
+ * user navigated away, an RxJS callback on a stream that has not been unsubscribed yet). v2 had no
+ * injector at all there, so the same code used to be harmless; building a real query would now
+ * throw NG0205 from inside the view's cleanup phase, with no hint about which query caused it.
+ *
+ * Everything reads as "prepared but never executed": `execute()` and friends are no-ops, signals
+ * stay `null`, observables complete immediately. Nothing here touches Angular's DI, which is the
+ * point — there is no live injector left to bind to.
+ */
+const createInertQuery = () => {
+    const inertSignal = (value) => Object.assign(signal(value), { asObservable: () => of(value) });
+    const noop = () => {
+        /* the query is inert — there is nothing to execute, reset or destroy */
+    };
+    const base = {
+        args: inertSignal(null),
+        response: inertSignal(null),
+        latestHttpEvent: inertSignal(null),
+        loading: inertSignal(null),
+        error: inertSignal(null),
+        lastTimeExecutedAt: inertSignal(null),
+        triggeredBy: inertSignal(null),
+        id: inertSignal(null),
+        executionState: inertSignal(null),
+    };
+    const createSnapshot = () => ({ ...base, isAlive: inertSignal(false) });
+    // A DestroyRef that is already destroyed: callbacks registered on it are dropped rather than
+    // stored, so nothing keeps this object (or its registrant) alive.
+    const destroyRef = {
+        destroyed: true,
+        onDestroy: () => noop,
+    };
+    return {
+        ...base,
+        execute: noop,
+        createSnapshot,
+        reset: noop,
+        asReadonly: () => ({ ...base, createSnapshot }),
+        subtle: {
+            destroy: noop,
+            setResponse: noop,
+            setLoading: noop,
+            setError: noop,
+            request: inertSignal(null),
+            destroyRef,
+            injector: Injector.NULL,
+        },
+    };
+};
+
+/**
+ * Whether an injector can still be used. A destroyed `R3Injector` throws on `get()` rather than
+ * answering, so the throw itself is the answer; a node injector hands back a `DestroyRef` that
+ * reports its own state.
+ */
+const isInjectorUsable = (injector) => {
+    try {
+        return injector.get(DestroyRef, null, { optional: true })?.destroyed !== true;
+    }
+    catch {
+        return false;
+    }
+};
 class LegacyQueryCreator {
     constructor(options) {
         this.options = options;
         this.prepare = (args) => {
-            const injector = args?.injector ?? inject(Injector);
+            // v2's `prepare()` needed no injection context, so plenty of call sites are plain callbacks.
+            // Angular's raw NG0203 names neither the query nor the call site, which makes those a bisection
+            // exercise — replace it with an error that does.
+            const injector = args?.injector ??
+                (() => {
+                    try {
+                        return inject(Injector);
+                    }
+                    catch {
+                        throw legacyPrepareWithoutInjectionContext(this.options.name);
+                    }
+                })();
             let headers = new HttpHeaders();
             if (args?.headers) {
                 Object.entries(args.headers).forEach(([key, value]) => {
@@ -3364,6 +3595,17 @@ class LegacyQueryCreator {
                 ...(args?.queryParams ? { queryParams: args.queryParams } : {}),
                 headers,
             };
+            // A captured component injector routinely outlives its component here: a debounced search
+            // resolving after navigation, an RxJS callback on a stream torn down a tick later. That is not
+            // a programming error the way it would be in new code — v2 had no injector to destroy — so it
+            // yields a query that does nothing instead of an NG0205 raised from the view's cleanup phase.
+            if (!isInjectorUsable(injector)) {
+                if (isDevMode()) {
+                    console.warn(`${this.options.name ? `"${this.options.name}"` : 'A legacy query'}.prepare() was called with a destroyed injector, so an inert query was returned. ` +
+                        `This usually means a callback outlived the component whose injector it captured — guard the call site with DestroyRef.onDestroy, or pass an injector that outlives it.`);
+                }
+                return new LegacyQuery(createInertQuery(), queryArgs, this.options.entity, true);
+            }
             return runInInjectionContext(injector, () => {
                 return untracked(() => {
                     const newQuery = this.options.creator({
@@ -5453,6 +5695,14 @@ const validateWithV2Query = (path, config) => {
 };
 
 const generateUuid = () => randomId();
+/** @see CreateQueryClientConfigOptions.keepUnusedFor */
+const DEFAULT_KEEP_UNUSED_FOR = 300_000;
+/**
+ * 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.
+ */
+const MAX_UNUSED_ENTRIES = 50;
 const createQueryRepository = (config) => {
     const cache = new Map();
     const eventsSubject = new Subject();
@@ -5461,6 +5711,11 @@ const createQueryRepository = (config) => {
     const cacheVersion = signal(0, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "cacheVersion" }] : /* istanbul ignore next */ []));
     const bumpCacheVersion = () => cacheVersion.update((v) => v + 1);
+    const resolveKeepUnusedFor = (creatorOptions, shouldCache) => {
+        if (config.retentionEnabled === false || !shouldCache)
+            return 0;
+        return Math.max(0, creatorOptions?.keepUnusedFor ?? config.keepUnusedFor ?? DEFAULT_KEEP_UNUSED_FOR);
+    };
     const request = (options) => {
         const { args, creatorOptions, runQueryOptions } = options;
         const shouldCache = creatorOptions?.subtle?.useQueryRepositoryCache === false
@@ -5486,6 +5741,7 @@ const createQueryRepository = (config) => {
             })
             : false;
         const trackingKey = cacheKey || generateUuid();
+        const keepUnusedFor = resolveKeepUnusedFor(creatorOptions, shouldCache);
         const previousKey = options.previousKey;
         if (cacheKey !== previousKey && previousKey) {
             unbind(previousKey, options.consumerDestroyRef);
@@ -5493,7 +5749,10 @@ const createQueryRepository = (config) => {
         if (shouldCache && cacheKey) {
             const cacheEntry = cache.get(cacheKey);
             if (cacheEntry) {
-                bind(cacheKey, options.consumerDestroyRef, cacheEntry.request, options.isSecure ?? false, true);
+                // The entry may have been sitting out its `keepUnusedFor` window — a consumer binding again
+                // makes it live, so the pending eviction must go.
+                cancelEviction(cacheEntry);
+                bind(cacheKey, options.consumerDestroyRef, cacheEntry.request, options.isSecure ?? false, true, keepUnusedFor);
                 if (!runQueryOptions?.allowCache || cacheEntry.request.isStale()) {
                     cacheEntry.request.execute({ allowCache: runQueryOptions?.allowCache });
                 }
@@ -5506,13 +5765,43 @@ const createQueryRepository = (config) => {
             method: options.method,
             dependencies: config.dependencies,
             clientOptions: creatorOptions,
+            clientHeaders: config.headers,
             cacheAdapter: config.cacheAdapter,
             retryFn: options.retryFn ?? config.retryFn,
         });
         request.execute();
-        bind(trackingKey, options.consumerDestroyRef, request, options.isSecure ?? false, shouldCache);
+        bind(trackingKey, options.consumerDestroyRef, request, options.isSecure ?? false, shouldCache, keepUnusedFor);
         return { key: trackingKey, request };
     };
+    /** Tears an entry down for good, whether it currently has consumers or not. */
+    const destroyEntry = (key, cacheEntry) => {
+        clearTimeout(cacheEntry.evictTimer);
+        cacheEntry.request.destroy();
+        cacheEntry.eventSubscription?.unsubscribe();
+        cache.delete(key);
+    };
+    const cancelEviction = (cacheEntry) => {
+        if (cacheEntry.evictTimer === undefined)
+            return;
+        clearTimeout(cacheEntry.evictTimer);
+        cacheEntry.evictTimer = undefined;
+        cacheEntry.unusedSince = undefined;
+    };
+    /** Drops the least recently orphaned unused entries until the cap is respected again. */
+    const enforceUnusedEntryLimit = () => {
+        const unused = Array.from(cache.entries()).filter(([, entry]) => entry.consumers.size === 0);
+        if (unused.length <= MAX_UNUSED_ENTRIES)
+            return;
+        unused.sort(([, a], [, b]) => (a.unusedSince ?? 0) - (b.unusedSince ?? 0));
+        for (const [key, entry] of unused.slice(0, unused.length - MAX_UNUSED_ENTRIES)) {
+            destroyEntry(key, entry);
+        }
+    };
+    const retain = (key, cacheEntry) => {
+        cacheEntry.unusedSince = Date.now();
+        cacheEntry.evictTimer = setTimeout(() => evict(key), cacheEntry.keepUnusedFor);
+        enforceUnusedEntryLimit();
+    };
     const unbind = (key, consumerDestroyRef) => {
         if (key === null)
             return false;
@@ -5521,26 +5810,41 @@ const createQueryRepository = (config) => {
             return false;
         cacheEntry.consumers.delete(consumerDestroyRef);
         if (cacheEntry.consumers.size === 0) {
-            cacheEntry.request.destroy();
-            cacheEntry.eventSubscription?.unsubscribe();
-            cache.delete(key);
+            // Only data is worth keeping around: an entry that never produced a response has nothing to
+            // hand back to a returning consumer, so it is aborted immediately as it always was.
+            if (cacheEntry.keepUnusedFor > 0 && cacheEntry.request.response() !== null) {
+                retain(key, cacheEntry);
+            }
+            else {
+                destroyEntry(key, cacheEntry);
+            }
         }
         bumpCacheVersion();
         return true;
     };
     const unbindAllSecure = () => {
         for (const [key, cacheEntry] of cache.entries()) {
-            if (cacheEntry.isSecure) {
-                for (const consumerDestroyRef of cacheEntry.consumers.keys()) {
-                    unbind(key, consumerDestroyRef);
-                }
-                cacheEntry.eventSubscription?.unsubscribe();
-                cache.delete(key);
-            }
+            if (!cacheEntry.isSecure)
+                continue;
+            // Force the teardown instead of routing through `unbind`: a logged out session must not leave a
+            // retained response body behind waiting out its `keepUnusedFor` window.
+            cacheEntry.consumers.clear();
+            destroyEntry(key, cacheEntry);
         }
         bumpCacheVersion();
+        eventsSubject.next({ type: 'unbind-all-secure' });
+    };
+    const refreshInUse = () => {
+        for (const cacheEntry of cache.values()) {
+            if (cacheEntry.consumers.size === 0)
+                continue;
+            // Re-firing a mutation would be a side effect nobody asked for, so only reads are refreshed.
+            if (!shouldCacheQuery(cacheEntry.request.method))
+                continue;
+            cacheEntry.request.execute({ force: true });
+        }
     };
-    const bind = (key, consumerDestroyRef, request, isSecure, allowReuse) => {
+    const bind = (key, consumerDestroyRef, request, isSecure, allowReuse, keepUnusedFor) => {
         const destroyListener = consumerDestroyRef.onDestroy(() => unbind(key, consumerDestroyRef));
         const cacheEntry = cache.get(key);
         if (cacheEntry && allowReuse) {
@@ -5567,6 +5871,7 @@ const createQueryRepository = (config) => {
                 request,
                 isSecure,
                 eventSubscription,
+                keepUnusedFor,
             });
         }
         bumpCacheVersion();
@@ -5575,21 +5880,21 @@ const createQueryRepository = (config) => {
         key,
         isSecure: entry.isSecure,
         consumerCount: entry.consumers.size,
+        isUnused: entry.consumers.size === 0,
         request: entry.request,
     }));
     const evict = (key) => {
         const entry = cache.get(key);
         if (!entry)
             return;
-        entry.request.destroy();
-        entry.eventSubscription?.unsubscribe();
-        cache.delete(key);
+        destroyEntry(key, entry);
         bumpCacheVersion();
     };
     const repository = {
         request,
         unbind,
         unbindAllSecure,
+        refreshInUse,
         events$: eventsSubject.asObservable(),
         subtle: {
             cacheEntries,
@@ -5606,11 +5911,15 @@ const createQueryClient = (options) => createRootProvider(() => {
     const injector = inject(Injector);
     const repository = createQueryRepository({
         ...options,
+        // Retaining unused entries on the server would pin response bodies (and a pending timer) inside
+        // a per-request injector for the whole window, so retention is browser only.
+        retentionEnabled: isPlatformBrowser(inject(PLATFORM_ID)),
         dependencies: { httpClient, ngErrorHandler, injector },
     });
     const client = {
         repository,
         baseUrl: options.baseUrl,
+        refreshQueriesInUse: () => repository.refreshInUse(),
     };
     return client;
 }, {
@@ -6453,6 +6762,7 @@ const createBearerAuthProviderImpl = (config) => {
         latestExecutedQuery: latestExecutedQuery.asReadonly(),
         latestNonInternalQuery: latestNonInternalQuery.asReadonly(),
         executionState: executionState.asReadonly(),
+        setTokens,
         logout,
         afterTokenRefresh$,
     };
@@ -7579,7 +7889,7 @@ class DateArrayQueryField {
         };
     }
 }
-const IGNORED_FILTER_COUNT_FIELDS = ['page', 'skip', 'take', 'limit', 'sort', 'sortBy', 'sortOrder', 'query', 'search'];
+const IGNORED_FILTER_COUNT_FIELDS$1 = ['page', 'skip', 'take', 'limit', 'sort', 'sortBy', 'sortOrder', 'query', 'search'];
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class QueryForm {
     get _formValue() {
@@ -7654,7 +7964,7 @@ class QueryForm {
          */
         this.activeFilterCount$ = this.changes$.pipe(map(({ currentValue }) => Object.entries(currentValue)
             .map(([key, value]) => {
-            if (IGNORED_FILTER_COUNT_FIELDS.includes(key) || this._fields[key]?.data.skipInFilterCount) {
+            if (IGNORED_FILTER_COUNT_FIELDS$1.includes(key) || this._fields[key]?.data.skipInFilterCount) {
                 return true;
             }
             return this._isDefaultValue(key, value);
@@ -8020,6 +8330,433 @@ class QueryForm {
     }
 }
 
+/** URL sentinel for an explicit `null` value (a bare empty param would be ambiguous). */
+const ET_NULL_VALUE = 'ET_NULL__';
+/**
+ * Fields excluded from `activeFilterCount` by default — pagination, sorting and
+ * search are navigation state, not filters.
+ */
+const IGNORED_FILTER_COUNT_FIELDS = [
+    'page',
+    'skip',
+    'take',
+    'limit',
+    'sort',
+    'sortBy',
+    'sortOrder',
+    'query',
+    'search',
+];
+const resolveDefault = (def) => {
+    const { defaultValue } = def;
+    return typeof defaultValue === 'function' ? defaultValue() : (defaultValue ?? null);
+};
+const buildDefaults = (fields) => {
+    const out = {};
+    for (const [key, def] of Object.entries(fields)) {
+        out[key] = resolveDefault(def);
+    }
+    return out;
+};
+const changedKeysBetween = (previous, current) => Object.keys(current).filter((key) => !equal(previous?.[key], current[key]));
+/** Best-effort URL string → value coercion, mirroring the auto-transform of the legacy QueryForm. */
+const autoCoerce = (raw, defaultValue) => {
+    if (raw === ET_NULL_VALUE)
+        return null;
+    if (typeof raw !== 'string')
+        return raw;
+    const defaultIsNumber = typeof defaultValue === 'number';
+    const looksNumeric = raw.trim() === raw && !raw.startsWith('0') && !raw.endsWith('.') && !isNaN(Number(raw));
+    if (defaultIsNumber || (looksNumeric && raw !== '')) {
+        return transformToNumber(raw);
+    }
+    if (raw === 'true' || raw === 'false') {
+        return transformToBoolean(raw);
+    }
+    return raw;
+};
+const computeFilterCount = (fields, value, defaults) => {
+    let count = 0;
+    for (const [key, def] of Object.entries(fields)) {
+        if (IGNORED_FILTER_COUNT_FIELDS.includes(key) || def.skipInFilterCount)
+            continue;
+        if (!equal(value[key], defaults[key]))
+            count++;
+    }
+    return count;
+};
+const createBranch = (fields, initial, injector) => {
+    const defaults = buildDefaults(fields);
+    const model = signal(clone(initial), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "model" }] : /* istanbul ignore next */ []));
+    const tree = form(model, { injector });
+    return {
+        fields: tree,
+        value: model.asReadonly(),
+        activeFilterCount: computed(() => computeFilterCount(fields, model(), defaults)),
+        setValue: (value) => model.set(clone(value)),
+        patchValue: (value) => model.update((cur) => ({ ...cur, ...value })),
+        resetFieldToDefault: (key) => model.update((cur) => ({ ...cur, [key]: defaults[key] })),
+        resetAllFieldsToDefault: () => model.set(clone(defaults)),
+    };
+};
+/**
+ * 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" />
+ */
+class QueryFormSignals {
+    constructor(config) {
+        this._router = inject(Router);
+        this._route = inject(ActivatedRoute);
+        this._injector = inject(Injector);
+        this._previous = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_previous" }] : /* istanbul ignore next */ []));
+        this._observing = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_observing" }] : /* istanbul ignore next */ []));
+        this._queryParamChanges = injectQueryParamChanges();
+        this._pendingTimer = null;
+        this._skipNextResets = false;
+        assertInInjectionContext(QueryFormSignals);
+        this._fields = config.fields;
+        this._prefix = config.queryParamPrefix;
+        this._defaults = buildDefaults(config.fields);
+        this.defaultValue = clone(this._defaults);
+        const initial = clone(this._defaults);
+        this._model = signal(initial, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_model" }] : /* istanbul ignore next */ []));
+        this._committed = signal(clone(initial), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_committed" }] : /* istanbul ignore next */ []));
+        this.fields = form(this._model);
+        this.value = this._committed.asReadonly();
+        this.previousValue = this._previous.asReadonly();
+        this.changes = computed(() => ({ previousValue: this._previous(), currentValue: this._committed() }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "changes" }] : /* istanbul ignore next */ []));
+        this.activeFilterCount = computed(() => computeFilterCount(this._fields, this._committed(), this._defaults), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activeFilterCount" }] : /* istanbul ignore next */ []));
+        // React to live control edits: schedule a debounced commit.
+        effect(() => {
+            const live = this._model();
+            untracked(() => this._onLiveChange(live));
+        });
+        // React to navigation (back/forward, external links): apply URL → form immediately.
+        effect(() => {
+            const changes = this._queryParamChanges();
+            untracked(() => {
+                if (!this._observing() || this._observeOptions?.syncOnNavigation === false)
+                    return;
+                this._applyFromUrl(changes);
+            });
+        });
+        inject(DestroyRef).onDestroy(() => this._cleanup());
+    }
+    observe(options) {
+        if (this._observing()) {
+            if (isDevMode()) {
+                console.warn('QueryFormSignals.observe() was called more than once. Ignoring the extra call.');
+            }
+            return this;
+        }
+        this._observeOptions = options;
+        this._observing.set(true);
+        if (options?.syncOnNavigation !== false) {
+            this._applyFromUrl(this._route.snapshot.queryParams);
+        }
+        // Commit whatever the model holds now (URL-restored or programmatic defaults).
+        this._flush();
+        return this;
+    }
+    unobserve() {
+        this._cleanup();
+    }
+    setValue(value, options) {
+        if (options?.skipResets)
+            this._skipNextResets = true;
+        this._model.set(clone(value));
+    }
+    patchValue(value, options) {
+        if (options?.skipResets)
+            this._skipNextResets = true;
+        this._model.update((cur) => ({ ...cur, ...value }));
+    }
+    resetFieldToDefault(key, options) {
+        if (options?.skipResets)
+            this._skipNextResets = true;
+        this._model.update((cur) => ({ ...cur, [key]: this._defaults[key] }));
+    }
+    resetFieldsToDefault(keys, options) {
+        if (options?.skipResets)
+            this._skipNextResets = true;
+        this._model.update((cur) => {
+            const next = { ...cur };
+            for (const key of keys) {
+                next[key] = this._defaults[key];
+            }
+            return next;
+        });
+    }
+    resetAllFieldsToDefault(options) {
+        const skip = new Set((options?.skipFields ?? []).map((key) => key));
+        const keys = Object.keys(this._fields).filter((key) => !skip.has(key));
+        this.resetFieldsToDefault(keys, options);
+    }
+    /** Create a detached editor over the same fields, seeded from the current committed value. */
+    branch() {
+        return createBranch(this._fields, clone(this._committed()), this._injector);
+    }
+    _onLiveChange(live) {
+        if (!this._observing())
+            return;
+        if (equal(live, this._committed()))
+            return;
+        const changedKeys = changedKeysBetween(this._committed(), live);
+        const debounceMs = this._resolveDebounce(changedKeys, live);
+        this._clearTimer();
+        if (debounceMs === null) {
+            this._flush();
+        }
+        else {
+            this._pendingTimer = setTimeout(() => {
+                this._pendingTimer = null;
+                this._flush();
+            }, debounceMs);
+        }
+    }
+    /** Shortest-debounce-wins; `null` means commit immediately. */
+    _resolveDebounce(changedKeys, live) {
+        if (!changedKeys.length)
+            return null;
+        const times = [];
+        for (const key of changedKeys) {
+            const def = this._fields[key];
+            if (!def)
+                return null;
+            if (def.disableDebounceIfFalsy && !live[key])
+                return null;
+            if (def.debounce === undefined)
+                return null;
+            times.push(def.debounce);
+        }
+        return Math.min(...times);
+    }
+    _flush() {
+        this._clearTimer();
+        const live = this._model();
+        const previous = this._committed();
+        if (equal(live, previous)) {
+            this._skipNextResets = false;
+            return;
+        }
+        const changedKeys = changedKeysBetween(previous, live);
+        const next = this._skipNextResets ? { ...live } : this._applyResets(live, changedKeys);
+        this._skipNextResets = false;
+        this._previous.set(clone(previous));
+        this._committed.set(clone(next));
+        // Reflect any reset overrides back into the bound controls. The effect re-runs
+        // but no-ops because the model now equals the committed value.
+        if (!equal(next, live)) {
+            this._model.set(clone(next));
+        }
+        if (this._observing() && this._observeOptions?.writeToQueryParams !== false) {
+            this._writeToUrl(next);
+        }
+    }
+    _applyResets(live, changedKeys) {
+        const next = { ...live };
+        for (const [key, def] of Object.entries(this._fields)) {
+            const resets = def.isResetBy;
+            if (!resets?.length)
+                continue;
+            const triggered = resets.some((resetKey) => {
+                if (!(resetKey in this._fields)) {
+                    if (isDevMode()) {
+                        console.warn(`QueryFormSignals: isResetBy references unknown field "${resetKey}". Is it a typo?`);
+                    }
+                    return false;
+                }
+                return changedKeys.includes(resetKey);
+            });
+            if (!triggered)
+                continue;
+            const defaultValue = this._defaults[key];
+            if (!equal(next[key], defaultValue)) {
+                next[key] = defaultValue;
+            }
+        }
+        return next;
+    }
+    _applyFromUrl(params) {
+        const current = { ...this._committed() };
+        let changed = false;
+        for (const [key, def] of Object.entries(this._fields)) {
+            const raw = params[this._paramKey(key)];
+            if (raw === undefined)
+                continue;
+            const value = raw === ET_PROPERTY_REMOVED ? this._defaults[key] : this._deserialize(def, raw);
+            if (!equal(current[key], value)) {
+                current[key] = value;
+                changed = true;
+            }
+        }
+        if (!changed)
+            return;
+        this._commitFromUrl(current);
+    }
+    _commitFromUrl(next) {
+        this._clearTimer();
+        this._previous.set(clone(this._committed()));
+        this._committed.set(clone(next));
+        // Feed the URL value into the live model & bound controls; the effect no-ops (model === committed).
+        this._model.set(clone(next));
+    }
+    _deserialize(def, raw) {
+        if (def.queryParamToValue)
+            return def.queryParamToValue(raw);
+        if (def.skipAutoTransform)
+            return raw;
+        return autoCoerce(raw, resolveDefault(def));
+    }
+    _writeToUrl(value) {
+        const queryParams = {};
+        for (const [key, def] of Object.entries(this._fields)) {
+            const paramKey = this._paramKey(key);
+            const fieldValue = value[key];
+            const isDefault = equal(fieldValue, this._defaults[key]);
+            const writeToUrl = def.appendToUrl !== false;
+            const writeDefault = def.appendDefaultValueToUrl === true;
+            if (!writeToUrl || (isDefault && !writeDefault)) {
+                queryParams[paramKey] = undefined;
+            }
+            else if (def.valueToQueryParam) {
+                queryParams[paramKey] = def.valueToQueryParam(fieldValue);
+            }
+            else {
+                queryParams[paramKey] = fieldValue === null ? ET_NULL_VALUE : fieldValue;
+            }
+        }
+        queueMicrotask(() => {
+            this._router.navigate([], {
+                queryParams,
+                queryParamsHandling: 'merge',
+                replaceUrl: this._observeOptions?.replaceUrl,
+            });
+        });
+    }
+    _paramKey(key) {
+        const prefix = this._prefix;
+        if (!prefix)
+            return key;
+        return `${typeof prefix === 'string' ? prefix : prefix()}-${key}`;
+    }
+    _clearTimer() {
+        if (this._pendingTimer !== null) {
+            clearTimeout(this._pendingTimer);
+            this._pendingTimer = null;
+        }
+    }
+    _cleanup() {
+        if (!this._observing())
+            return;
+        this._observing.set(false);
+        this._clearTimer();
+        if (this._observeOptions?.writeToQueryParams === false)
+            return;
+        const queryParams = {};
+        for (const key of Object.keys(this._fields)) {
+            queryParams[this._paramKey(key)] = undefined;
+        }
+        queueMicrotask(() => {
+            this._router.navigate([], { queryParams, queryParamsHandling: 'merge', replaceUrl: true });
+        });
+    }
+}
+/**
+ * Create a {@link QueryFormSignals}. Call `.observe()` to start syncing with the
+ * URL. Must be called in an injection context.
+ */
+const createQueryForm = (config) => new QueryFormSignals(config);
+
+const normalizeConfig = (config) => {
+    if (!config)
+        return {};
+    const { isResetBy, ...rest } = config;
+    return {
+        ...rest,
+        isResetBy: isResetBy === undefined ? undefined : Array.isArray(isResetBy) ? isResetBy : [isResetBy],
+    };
+};
+/**
+ * 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'] })
+ */
+const queryField = (config) => ({
+    defaultValue: null,
+    ...normalizeConfig(config),
+});
+/**
+ * A debounced free-text search field. Debounces typing by 300ms but applies
+ * clearing immediately (`disableDebounceIfFalsy`).
+ */
+const searchQueryField = (config) => ({
+    defaultValue: null,
+    debounce: 300,
+    disableDebounceIfFalsy: true,
+    ...normalizeConfig(config),
+});
+/**
+ * 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.
+ */
+const sortQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToSort,
+    valueToQueryParam: transformToSortQueryParam,
+    ...normalizeConfig(config),
+});
+/** A field holding a list of strings. */
+const stringArrayQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToStringArray,
+    ...normalizeConfig(config),
+});
+/** A field holding a list of numbers. */
+const numberArrayQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToNumberArray,
+    ...normalizeConfig(config),
+});
+/** A field holding a list of booleans. */
+const booleanArrayQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToBooleanArray,
+    ...normalizeConfig(config),
+});
+/** A single date field (expects an ISO/`Date`-parseable string in the URL). */
+const dateQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToDate,
+    ...normalizeConfig(config),
+});
+/** A field holding a list of dates. */
+const dateArrayQueryField = (config) => ({
+    defaultValue: null,
+    queryParamToValue: transformToDateArray,
+    ...normalizeConfig(config),
+});
+
 // codes 1000-1999
 const WebSocketRuntimeErrorCode = {
     // Web Socket Client
@@ -8178,5 +8915,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { 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, 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, consumeSuppressQueryStackDevtools, 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, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryDevtoolsEnabled, 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, registerQueryDevtoolsEntry, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, stringifyQueryRoute, suppressNextQueryStackDevtools, 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 { 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, 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, consumeSuppressQueryStackDevtools, 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, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, 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, registerQueryDevtoolsEntry, removeFrom, request, resetExecuteState, resetPageOnError, searchQueryField, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRoute, suppressNextQueryStackDevtools, 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 };
 //# sourceMappingURL=ethlete-query.mjs.map