@ethlete/query 6.0.0-next.26 → 6.0.0-next.28

package/fesm2022/ethlete-query.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, setCookie, deleteCookie, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
-import { filter, Subject, Subscription, defer, throwError, timer, switchMap, tap, retry, catchError, take, of, firstValueFrom, merge, fromEvent, throttleTime, interval, combineLatest, map, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, takeWhile, EMPTY, withLatestFrom, debounceTime } from 'rxjs';
+import { filter, Subject, Subscription, defer, throwError, timer, switchMap, tap, retry, catchError, take, of, merge, firstValueFrom, fromEvent, throttleTime, interval, combineLatest, map, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, takeWhile, EMPTY, withLatestFrom, debounceTime } from 'rxjs';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
@@ -3690,6 +3690,9 @@ const createSecureExecuteFactory = (options) => {
     let authQuerySubscription = Subscription.EMPTY;
     let tokenRefreshSubscription = Subscription.EMPTY;
     let tokenWaitSubscription = Subscription.EMPTY;
+    let sessionRestartSubscription = Subscription.EMPTY;
+    let hasExecuted = false;
+    let lastExecuteArgs;
     const reset = () => {
         authQuerySubscription.unsubscribe();
         authQuerySubscription = Subscription.EMPTY;
@@ -3697,6 +3700,8 @@ const createSecureExecuteFactory = (options) => {
         tokenRefreshSubscription = Subscription.EMPTY;
         tokenWaitSubscription.unsubscribe();
         tokenWaitSubscription = Subscription.EMPTY;
+        sessionRestartSubscription.unsubscribe();
+        sessionRestartSubscription = Subscription.EMPTY;
         resetExecuteState({
             executeState,
             executeOptions: { deps: options.deps, state: options.state },
@@ -3705,9 +3710,26 @@ const createSecureExecuteFactory = (options) => {
     // 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.
+    //
+    // Resetting alone leaves it idle for good though: a self-executing query runs once, at creation,
+    // and nothing runs it again - so anything still mounted across a logout has to be re-armed for
+    // the next session. That re-arm waits on the token instead of re-running here: `logout()` clears
+    // `latestExecutedQuery` and `executionState` only *after* emitting this event, so everything read
+    // synchronously still describes the session that just ended.
     options.deps.client.repository.events$
         .pipe(filter((event) => event.type === 'unbind-all-secure'), takeUntilDestroyed(options.deps.destroyRef))
-        .subscribe(() => reset());
+        .subscribe(() => {
+        const shouldRestart = hasExecuted && options.autoExecutes;
+        const restartArgs = lastExecuteArgs;
+        reset();
+        if (!shouldRestart)
+            return;
+        sessionRestartSubscription = toObservable(options.authProvider.accessToken, {
+            injector: options.deps.injector,
+        })
+            .pipe(filter(Boolean), take(1), tap(() => exec(restartArgs)))
+            .subscribe();
+    });
     const error = (query) => {
         const state = options.state;
         state.error.set(query.error());
@@ -3768,18 +3790,29 @@ const createSecureExecuteFactory = (options) => {
             args: executeArgs?.args ?? options.state.args(),
             options: executeArgs?.options,
         };
+        hasExecuted = true;
+        lastExecuteArgs = execArgsWithDefaults;
         authQuerySubscription.unsubscribe();
         authQuerySubscription = Subscription.EMPTY;
         tokenRefreshSubscription.unsubscribe();
         tokenRefreshSubscription = Subscription.EMPTY;
         tokenWaitSubscription.unsubscribe();
         tokenWaitSubscription = Subscription.EMPTY;
+        sessionRestartSubscription.unsubscribe();
+        sessionRestartSubscription = Subscription.EMPTY;
         tokenRefreshSubscription = options.authProvider.afterTokenRefresh$
             .pipe(filter(() => {
             const currentError = options.state.error();
             return currentError?.code === 401;
         }), take(1), tap(() => exec(execArgsWithDefaults)))
             .subscribe();
+        // `setTokens()` seeds an auth session from outside the query registry (an SSO/OIDC callback, a
+        // native shell) - no query ever runs for `latestExecutedQuery` to report, so a successful token
+        // seed is treated as an auth query that already resolved.
+        if (options.authProvider.executionState()?.type === 'tokenSeed') {
+            authAndExecWhenTokenReady(execArgsWithDefaults);
+            return;
+        }
         const latestQuery = options.authProvider.latestExecutedQuery();
         const authQuery = latestQuery?.snapshot;
         // This might happen if a secure query gets executed while the auth query has just been created.
@@ -3787,10 +3820,9 @@ const createSecureExecuteFactory = (options) => {
         const isAuthQueryFreshlyExecuted = authQuery?.lastTimeExecutedAt() === null;
         if (!authQuery || authQuery.loading() || isAuthQueryFreshlyExecuted) {
             options.state.loading.set({ executeTime: Date.now(), progress: null });
-            authQuerySubscription = toObservable(options.authProvider.latestExecutedQuery, {
+            const latestExecutedQuery$ = toObservable(options.authProvider.latestExecutedQuery, {
                 injector: options.deps.injector,
-            })
-                .pipe(switchMap((latestQuery) => {
+            }).pipe(switchMap((latestQuery) => {
                 if (!latestQuery)
                     return of(null);
                 const query = latestQuery.snapshot;
@@ -3804,8 +3836,14 @@ const createSecureExecuteFactory = (options) => {
                         authAndExecWhenTokenReady(execArgsWithDefaults);
                     }
                 }));
-            }))
-                .subscribe();
+            }));
+            // A `setTokens()` call that lands while this is already waiting (e.g. the SSO redirect
+            // resolves after this secure query mounted) never touches `latestExecutedQuery` either -
+            // wake up on `executionState` becoming a token seed too.
+            const tokenSeed$ = toObservable(options.authProvider.executionState, {
+                injector: options.deps.injector,
+            }).pipe(filter((state) => state?.type === 'tokenSeed'), take(1), tap(() => authAndExecWhenTokenReady(execArgsWithDefaults)));
+            authQuerySubscription = merge(latestExecutedQuery$, tokenSeed$).subscribe();
         }
         else if (authQuery.response()) {
             authAndExecWhenTokenReady(execArgsWithDefaults);
@@ -3828,6 +3866,7 @@ const createSecureExecuteFn = (executeOptions) => {
         authProvider,
         deps: executeOptions.deps,
         state: executeOptions.state,
+        autoExecutes: shouldAutoExecuteQuery(executeOptions.creatorInternals.method) && !executeOptions.queryConfig.onlyManualExecution,
         transformAuthAndExec: (executeArgs, _tokens, headers, executeState) => {
             const { options: runOptions } = executeArgs ?? {};
             const updatedArgs = { ...(executeArgs?.args ?? {}), headers };
@@ -6260,6 +6299,8 @@ const createSecureGqlExecuteFn = (executeOptions) => {
         authProvider,
         deps: executeOptions.deps,
         state: executeOptions.state,
+        autoExecutes: shouldAutoExecuteGqlQuery(executeOptions.creatorInternals.method) &&
+            !executeOptions.queryConfig.onlyManualExecution,
         transformAuthAndExec: (executeArgs, _tokens, headers, executeState) => {
             const { args, options: runOptions } = executeArgs ?? {};
             const query = transformGql(executeOptions.creatorInternals.query);
@@ -11086,12 +11127,11 @@ const nextQueryFormDevtoolsId = (name) => {
     return `query-form|${name}#${seq}`;
 };
 /**
- * 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.
+ * Define a {@link QueryFormSignals}. Call `.observe()` to start syncing with the
+ * URL. Must be called in an injection context.
  *
  * @example
- * const qf = createQueryForm({
+ * const qf = defineQueryForm({
  *   fields: {
  *     search: searchQueryField(),
  *     sort: sortQueryField(),
@@ -11100,191 +11140,131 @@ const nextQueryFormDevtoolsId = (name) => {
  * }).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.queryParamChanges = injectQueryParamChanges();
-        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.pendingTimer = null;
-        this.commitPending = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "commitPending" }] : /* istanbul ignore next */ []));
-        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);
-        const devtoolsName = config.name ?? (typeof this.prefix === 'string' ? this.prefix : 'form');
-        const devtoolsId = isQueryDevtoolsEnabled() ? nextQueryFormDevtoolsId(devtoolsName) : null;
-        // Reading `value` is how a query's args pick the form up, so the devtools learn which query a form
-        // drives by noting the read - see `QueryDevtoolsFormLinksHandle`.
-        this.value = devtoolsId
-            ? computed(() => {
-                noteQueryFormRead(devtoolsId);
-                return this.committed();
-            })
-            : 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);
-            });
-        });
-        const destroyRef = inject(DestroyRef);
-        destroyRef.onDestroy(() => this.cleanup());
-        if (devtoolsId) {
-            destroyRef.onDestroy(registerQueryDevtoolsEntry({
-                id: devtoolsId,
-                kind: 'query-form',
-                handle: this.devtoolsHandle(),
-                meta: { name: devtoolsName },
-            }));
-        }
-    }
-    observe(options) {
-        if (this.observing()) {
-            if (isDevMode()) {
-                console.warn('QueryFormSignals.observe() was called more than once. Ignoring the extra call.');
-            }
-            return this;
+const defineQueryForm = (config) => {
+    assertInInjectionContext(defineQueryForm);
+    const router = inject(Router);
+    const route = inject(ActivatedRoute);
+    const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
+    const queryParamChanges = injectQueryParamChanges();
+    const fieldDefs = config.fields;
+    const prefix = config.queryParamPrefix;
+    const defaults = buildDefaults(fieldDefs);
+    const defaultValue = clone(defaults);
+    /** Live field values (updated immediately by bound controls). */
+    const model = signal(clone(defaults), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "model" }] : /* istanbul ignore next */ []));
+    /** The committed (debounced) value that drives `value`, the URL and the filter count. */
+    const committed = signal(clone(defaults), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "committed" }] : /* istanbul ignore next */ []));
+    const previous = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "previous" }] : /* istanbul ignore next */ []));
+    const observing = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "observing" }] : /* istanbul ignore next */ []));
+    const commitPending = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "commitPending" }] : /* istanbul ignore next */ []));
+    let observeOptions;
+    let pendingTimer = null;
+    let skipNextResets = false;
+    const fields = form(model);
+    const activeFilterCount = computed(() => computeFilterCount(fieldDefs, committed(), defaults), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "activeFilterCount" }] : /* istanbul ignore next */ []));
+    const paramKey = (key) => {
+        if (!prefix)
+            return key;
+        return `${typeof prefix === 'string' ? prefix : prefix()}-${key}`;
+    };
+    /** What a field puts in the URL for a given value, or `undefined` when it writes nothing. */
+    const queryParamFor = (key, def, value) => {
+        const isDefault = equal(value, defaults[key]);
+        const writeToUrl = def.appendToUrl !== false;
+        const writeDefault = def.appendDefaultValueToUrl === true;
+        if (!writeToUrl || (isDefault && !writeDefault))
+            return undefined;
+        if (def.valueToQueryParam)
+            return def.valueToQueryParam(value);
+        return value === null ? ET_NULL_VALUE : value;
+    };
+    const deserialize = (def, raw) => {
+        if (def.queryParamToValue)
+            return def.queryParamToValue(raw);
+        if (def.skipAutoTransform)
+            return raw;
+        return autoCoerce(raw, resolveDefault(def));
+    };
+    const clearTimer = () => {
+        if (pendingTimer !== null) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
         }
-        this.observeOptions = options;
-        this.observing.set(true);
-        if (options?.syncOnNavigation !== false) {
-            this.applyFromUrl(this.route.snapshot.queryParams);
+        commitPending.set(false);
+    };
+    const writeToUrl = (value) => {
+        const queryParams = {};
+        for (const [key, def] of Object.entries(fieldDefs)) {
+            queryParams[paramKey(key)] = queryParamFor(key, def, value[key]);
         }
-        // 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;
+        queueMicrotask(() => {
+            router.navigate([], {
+                queryParams,
+                queryParamsHandling: 'merge',
+                replaceUrl: observeOptions?.replaceUrl,
+            });
         });
-    }
-    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);
-    }
-    /**
-     * The live view `<et-query-devtools>` renders. Only built while the devtools are installed - it walks
-     * every field on every change, which an app without them should not pay for.
-     */
-    devtoolsHandle() {
-        const fields = computed(() => {
-            const committed = this.committed();
-            const live = this.model();
-            return Object.entries(this._fields).map(([key, def]) => {
-                const value = committed[key];
-                return {
-                    key,
-                    paramKey: this.paramKey(key),
-                    value,
-                    liveValue: live[key],
-                    defaultValue: this.defaults[key],
-                    isDefault: equal(value, this.defaults[key]),
-                    queryParam: this.queryParamFor(key, def, value),
-                    debounceMs: def.debounce ?? null,
-                    isResetBy: def.isResetBy ?? [],
-                    countsAsFilter: !IGNORED_FILTER_COUNT_FIELDS.includes(key) && !def.skipInFilterCount,
-                };
+    };
+    const applyResets = (live, changedKeys) => {
+        const next = { ...live };
+        for (const [key, def] of Object.entries(fieldDefs)) {
+            const resets = def.isResetBy;
+            if (!resets?.length)
+                continue;
+            const triggered = resets.some((resetKey) => {
+                if (!(resetKey in fieldDefs)) {
+                    if (isDevMode()) {
+                        console.warn(`defineQueryForm: isResetBy references unknown field "${resetKey}". Is it a typo?`);
+                    }
+                    return false;
+                }
+                return changedKeys.includes(resetKey);
             });
-        }, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "fields" }] : /* istanbul ignore next */ []));
-        return {
-            fields,
-            // Not `this.value` - reading that from the panel would link the form to whichever query happens
-            // to be building its args at the time.
-            value: computed(() => this.committed()),
-            previousValue: computed(() => this.previous() ?? null),
-            defaultValue: this.defaults,
-            activeFilterCount: this.activeFilterCount,
-            isAtDefaults: computed(() => equal(this.committed(), this.defaults)),
-            isCommitPending: this.commitPending.asReadonly(),
-            isObserving: this.observing.asReadonly(),
-            resetField: (key) => this.resetFieldToDefault(key),
-            resetAll: () => this.resetAllFieldsToDefault(),
-        };
-    }
-    onLiveChange(live) {
-        if (!this.observing())
-            return;
-        if (equal(live, this.committed()))
+            if (!triggered)
+                continue;
+            const fieldDefault = defaults[key];
+            if (!equal(next[key], fieldDefault)) {
+                next[key] = fieldDefault;
+            }
+        }
+        return next;
+    };
+    const flush = () => {
+        clearTimer();
+        const live = model();
+        const prev = committed();
+        if (equal(live, prev)) {
+            skipNextResets = false;
             return;
-        const changedKeys = changedKeysBetween(this.committed(), live);
-        const debounceMs = this.resolveDebounce(changedKeys, live);
-        this.clearTimer();
-        if (debounceMs === null) {
-            this.flush();
         }
-        else {
-            this.commitPending.set(true);
-            this.pendingTimer = setTimeout(() => {
-                this.pendingTimer = null;
-                this.flush();
-            }, debounceMs);
+        const changedKeys = changedKeysBetween(prev, live);
+        const next = skipNextResets ? { ...live } : applyResets(live, changedKeys);
+        skipNextResets = false;
+        previous.set(clone(prev));
+        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)) {
+            model.set(clone(next));
         }
-    }
+        if (observing() && observeOptions?.writeToQueryParams !== false) {
+            writeToUrl(next);
+        }
+    };
     /** Shortest-debounce-wins; `null` means commit immediately. */
-    resolveDebounce(changedKeys, live) {
+    const resolveDebounce = (changedKeys, live) => {
         if (!changedKeys.length)
             return null;
         const times = [];
         for (const key of changedKeys) {
-            const def = this._fields[key];
+            const def = fieldDefs[key];
             if (!def)
                 return null;
             if (def.disableDebounceIfFalsy && !live[key])
@@ -11294,61 +11274,41 @@ class QueryFormSignals {
             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;
+    };
+    const onLiveChange = (live) => {
+        if (!observing())
             return;
+        if (equal(live, committed()))
+            return;
+        const changedKeys = changedKeysBetween(committed(), live);
+        const debounceMs = resolveDebounce(changedKeys, live);
+        clearTimer();
+        if (debounceMs === null) {
+            flush();
         }
-        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;
-            }
+        else {
+            commitPending.set(true);
+            pendingTimer = setTimeout(() => {
+                pendingTimer = null;
+                flush();
+            }, debounceMs);
         }
-        return next;
-    }
-    applyFromUrl(params) {
-        const current = { ...this.committed() };
+    };
+    const commitFromUrl = (next) => {
+        clearTimer();
+        previous.set(clone(committed()));
+        committed.set(clone(next));
+        // Feed the URL value into the live model & bound controls; the effect no-ops (model === committed).
+        model.set(clone(next));
+    };
+    const applyFromUrl = (params) => {
+        const current = { ...committed() };
         let changed = false;
-        for (const [key, def] of Object.entries(this._fields)) {
-            const raw = params[this.paramKey(key)];
+        for (const [key, def] of Object.entries(fieldDefs)) {
+            const raw = params[paramKey(key)];
             if (raw === undefined)
                 continue;
-            const value = raw === ET_PROPERTY_REMOVED ? this.defaults[key] : this.deserialize(def, raw);
+            const value = raw === ET_PROPERTY_REMOVED ? defaults[key] : deserialize(def, raw);
             if (!equal(current[key], value)) {
                 current[key] = value;
                 changed = true;
@@ -11356,80 +11316,149 @@ class QueryFormSignals {
         }
         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));
-    }
-    /** What a field puts in the URL for a given value, or `undefined` when it writes nothing. */
-    queryParamFor(key, def, value) {
-        const isDefault = equal(value, this.defaults[key]);
-        const writeToUrl = def.appendToUrl !== false;
-        const writeDefault = def.appendDefaultValueToUrl === true;
-        if (!writeToUrl || (isDefault && !writeDefault))
-            return undefined;
-        if (def.valueToQueryParam)
-            return def.valueToQueryParam(value);
-        return value === null ? ET_NULL_VALUE : value;
-    }
-    writeToUrl(value) {
-        const queryParams = {};
-        for (const [key, def] of Object.entries(this._fields)) {
-            queryParams[this.paramKey(key)] = this.queryParamFor(key, def, value[key]);
-        }
-        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;
-        }
-        this.commitPending.set(false);
-    }
-    cleanup() {
-        if (!this.observing())
+        commitFromUrl(current);
+    };
+    const cleanup = () => {
+        if (!observing())
             return;
-        this.observing.set(false);
-        this.clearTimer();
-        if (this.observeOptions?.writeToQueryParams === false)
+        observing.set(false);
+        clearTimer();
+        if (observeOptions?.writeToQueryParams === false)
             return;
         const queryParams = {};
-        for (const key of Object.keys(this._fields)) {
-            queryParams[this.paramKey(key)] = undefined;
+        for (const key of Object.keys(fieldDefs)) {
+            queryParams[paramKey(key)] = undefined;
         }
         queueMicrotask(() => {
-            this.router.navigate([], { queryParams, queryParamsHandling: 'merge', replaceUrl: true });
+            router.navigate([], { queryParams, queryParamsHandling: 'merge', replaceUrl: true });
         });
+    };
+    const setValue = (value, options) => {
+        if (options?.skipResets)
+            skipNextResets = true;
+        model.set(clone(value));
+    };
+    const patchValue = (value, options) => {
+        if (options?.skipResets)
+            skipNextResets = true;
+        model.update((cur) => ({ ...cur, ...value }));
+    };
+    const resetFieldsToDefault = (keys, options) => {
+        if (options?.skipResets)
+            skipNextResets = true;
+        model.update((cur) => {
+            const next = { ...cur };
+            for (const key of keys) {
+                next[key] = defaults[key];
+            }
+            return next;
+        });
+    };
+    const devtoolsName = config.name ?? (typeof prefix === 'string' ? prefix : 'form');
+    const devtoolsId = isQueryDevtoolsEnabled() ? nextQueryFormDevtoolsId(devtoolsName) : null;
+    const queryForm = {
+        fields,
+        // Reading `value` is how a query's args pick the form up, so the devtools learn which query a form
+        // drives by noting the read - see `QueryDevtoolsFormLinksHandle`.
+        value: devtoolsId
+            ? computed(() => {
+                noteQueryFormRead(devtoolsId);
+                return committed();
+            })
+            : committed.asReadonly(),
+        previousValue: previous.asReadonly(),
+        changes: computed(() => ({ previousValue: previous(), currentValue: committed() })),
+        activeFilterCount,
+        defaultValue,
+        observe: (options) => {
+            if (observing()) {
+                if (isDevMode()) {
+                    console.warn('defineQueryForm: observe() was called more than once. Ignoring the extra call.');
+                }
+                return queryForm;
+            }
+            observeOptions = options;
+            observing.set(true);
+            if (options?.syncOnNavigation !== false) {
+                applyFromUrl(route.snapshot.queryParams);
+            }
+            // Commit whatever the model holds now (URL-restored or programmatic defaults).
+            flush();
+            return queryForm;
+        },
+        unobserve: () => cleanup(),
+        setValue,
+        patchValue,
+        resetFieldToDefault: (key, options) => resetFieldsToDefault([key], options),
+        resetFieldsToDefault,
+        resetAllFieldsToDefault: (options) => {
+            const skip = new Set((options?.skipFields ?? []).map((key) => key));
+            const keys = Object.keys(fieldDefs).filter((key) => !skip.has(key));
+            resetFieldsToDefault(keys, options);
+        },
+        branch: () => createBranch(fieldDefs, clone(committed()), injector),
+    };
+    // React to live control edits: schedule a debounced commit.
+    effect(() => {
+        const live = model();
+        untracked(() => onLiveChange(live));
+    });
+    // React to navigation (back/forward, external links): apply URL → form immediately.
+    effect(() => {
+        const changes = queryParamChanges();
+        untracked(() => {
+            if (!observing() || observeOptions?.syncOnNavigation === false)
+                return;
+            applyFromUrl(changes);
+        });
+    });
+    destroyRef.onDestroy(() => cleanup());
+    if (devtoolsId) {
+        /**
+         * The live view `<et-query-devtools>` renders. Only built while the devtools are installed - it walks
+         * every field on every change, which an app without them should not pay for.
+         */
+        const handle = {
+            fields: computed(() => {
+                const committedValue = committed();
+                const live = model();
+                return Object.entries(fieldDefs).map(([key, def]) => {
+                    const value = committedValue[key];
+                    return {
+                        key,
+                        paramKey: paramKey(key),
+                        value,
+                        liveValue: live[key],
+                        defaultValue: defaults[key],
+                        isDefault: equal(value, defaults[key]),
+                        queryParam: queryParamFor(key, def, value),
+                        debounceMs: def.debounce ?? null,
+                        isResetBy: def.isResetBy ?? [],
+                        countsAsFilter: !IGNORED_FILTER_COUNT_FIELDS.includes(key) && !def.skipInFilterCount,
+                    };
+                });
+            }),
+            // Not `queryForm.value` - reading that from the panel would link the form to whichever query happens
+            // to be building its args at the time.
+            value: computed(() => committed()),
+            previousValue: computed(() => previous() ?? null),
+            defaultValue: defaults,
+            activeFilterCount,
+            isAtDefaults: computed(() => equal(committed(), defaults)),
+            isCommitPending: commitPending.asReadonly(),
+            isObserving: observing.asReadonly(),
+            resetField: (key) => queryForm.resetFieldToDefault(key),
+            resetAll: () => queryForm.resetAllFieldsToDefault(),
+        };
+        destroyRef.onDestroy(registerQueryDevtoolsEntry({
+            id: devtoolsId,
+            kind: 'query-form',
+            handle,
+            meta: { name: devtoolsName },
+        }));
     }
-}
-/**
- * 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);
+    return queryForm;
+};
 
 const normalizeConfig = (config) => {
     if (!config)
@@ -11667,5 +11696,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, collectLeafPaths, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryForm, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsFaultInjectionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsOverridesFactory, setQueryDevtoolsRegistrar, setQueryDevtoolsStatsFactory, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, collectLeafPaths, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsFaultInjectionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsOverridesFactory, setQueryDevtoolsRegistrar, setQueryDevtoolsStatsFactory, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
 //# sourceMappingURL=ethlete-query.mjs.map