@ethlete/query 6.0.0-next.15 → 6.0.0-next.17

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @ethlete/query
 
+## 6.0.0-next.17
+
+### Minor Changes
+
+- [#3030](https://github.com/ethlete-io/ethdk/pull/3030) [`47e4109`](https://github.com/ethlete-io/ethdk/commit/47e41097adf96788120840bdd03cad25306628f2) Thanks [@github-actions](https://github.com/apps/github-actions)! - Add `validateWithQuery` (v3) and `validateWithV2Query` (v2) — query-backed async
+  validators for Angular signal forms. They adapt an `@ethlete/query` query into
+  `validateAsync`, so server-side validation runs through the query client (auth,
+  base route, caching, error normalization) instead of a raw `httpResource`. A
+  `422 FormViolationListView` maps each violation onto its child field by
+  `propertyPath` (via `mapViolationsToFormErrors`); success reports no errors and
+  network/other errors surface as a form-level error.
+
+## 6.0.0-next.16
+
+### Minor Changes
+
+- [`a41491d`](https://github.com/ethlete-io/ethdk/commit/a41491db447152e69902020d19bfc30bccf3b01d) Thanks [@TomTomB](https://github.com/TomTomB)! - Server violations → signal-forms bridge:
+  - `@ethlete/query`: `mapViolationsToFormErrors({ fieldTree, error, rewritePath?, onUnmappedViolation? })` maps an API error's violation list onto a signal form's fields (unmapped violations become form-level errors, violation-free failures degrade to a form-level `etServerError`), plus `extractFormViolations(error)`, `executeUntilSettled(query, executeArgs?)` for awaiting one execution as a settled snapshot, and the `isQueryErrorResponse` guard.
+  - `@ethlete/components`: `provideFormErrorMessageResolver(resolver)` lets apps centralize/localize the text `et-form-error` renders by error `kind`; the error's own `message` stays the default.
+
 ## 6.0.0-next.15
 
 ### Patch Changes

package/fesm2022/ethlete-query.mjs

@@ -1,13 +1,14 @@
 import * as i0 from '@angular/core';
-import { isDevMode, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, ElementRef, input, Pipe, ViewEncapsulation, Component, DOCUMENT, NgZone } from '@angular/core';
+import { isDevMode, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, ElementRef, input, Pipe, ViewEncapsulation, Component, resource, 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, merge, throttleTime } from 'rxjs';
+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 * as i1 from '@angular/forms';
 import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
+import { validateAsync } from '@angular/forms/signals';
 import { Router, ActivatedRoute } from '@angular/router';
 import { io } from 'socket.io-client';
 
@@ -1492,6 +1493,9 @@ const shouldRetryRequest = (options) => {
     return { retry: false };
 };
 
+const isQueryErrorResponse = (error) => {
+    return typeof error === 'object' && error !== null && 'raw' in error && 'retryState' in error && 'isList' in error;
+};
 const createQueryErrorResponse = (error) => {
     let err = error instanceof HttpErrorResponse ? error : null;
     if (!err) {
@@ -5060,6 +5064,216 @@ const removeFrom = (store, { where, id }) => {
         .subscribe();
 };
 
+/** `kind` of a `ValidationError` created from a single server violation. */
+const SERVER_VIOLATION_ERROR_KIND = 'etServerViolation';
+/** `kind` of the form-level fallback error created when a failed request carries no violations. */
+const SERVER_ERROR_KIND = 'etServerError';
+/**
+ * Extracts the violation list from a failed request in any of the shapes it may reach you:
+ * a `QueryErrorResponse` (from `query.error()` or a settled snapshot), a raw `HttpErrorResponse`,
+ * an already-unwrapped error body, or a plain violation array. Returns `[]` when the error
+ * carries no violations.
+ */
+const extractFormViolations = (error) => {
+    if (!error)
+        return [];
+    const body = isQueryErrorResponse(error) ? error.raw.error : error instanceof HttpErrorResponse ? error.error : error;
+    if (isSymfonyFormViolationListError(body)) {
+        return body.violations;
+    }
+    if (isSymfonyListError(body)) {
+        return body;
+    }
+    return [];
+};
+/**
+ * Maps a failed request's violations onto a signal-forms field tree as validation errors —
+ * the bridge between an API's violation list (`@ethlete/types` `FormViolationView`) and
+ * signal forms.
+ *
+ * Each violation's `propertyPath` (e.g. `items[2].name`) is resolved against `fieldTree`; a
+ * resolved violation becomes a `ServerViolationValidationError` bound to that field, an
+ * unresolved one becomes a form-level error (customizable via `onUnmappedViolation`). A failed
+ * request that carries no violations at all degrades to form-level `ServerValidationError`s
+ * built from the normalized error message — so returning this function's result from a
+ * `submit()` action never silently succeeds on failure.
+ *
+ * ```ts
+ * await submit(this.form, async (field) => {
+ *   const snapshot = await executeUntilSettled(this.createPost, { args: { body: field().value() } });
+ *   const error = snapshot.error();
+ *
+ *   if (!error) return;
+ *
+ *   return mapViolationsToFormErrors({ fieldTree: field, error });
+ * });
+ * ```
+ */
+const mapViolationsToFormErrors = (options) => {
+    const { fieldTree, error, rewritePath, onUnmappedViolation } = options;
+    if (error === null || error === undefined)
+        return [];
+    const violations = extractFormViolations(error);
+    if (!violations.length) {
+        // An empty violation array is an explicit "nothing to map" — only unrecognized error
+        // shapes degrade to the form-level fallback.
+        if (Array.isArray(error) && !error.length)
+            return [];
+        return createFallbackErrors(error);
+    }
+    const errors = [];
+    for (const violation of violations) {
+        const rawPath = violation.propertyPath;
+        const path = rawPath && rewritePath ? rewritePath(rawPath, violation) : rawPath;
+        const resolvedFieldTree = path ? resolveFieldTreePath(fieldTree, path) : null;
+        if (resolvedFieldTree) {
+            const mappedError = {
+                kind: SERVER_VIOLATION_ERROR_KIND,
+                message: violation.message,
+                fieldTree: resolvedFieldTree,
+                violation,
+            };
+            errors.push(mappedError);
+        }
+        else if (onUnmappedViolation) {
+            const customError = onUnmappedViolation(violation);
+            if (customError) {
+                errors.push(customError);
+            }
+        }
+        else {
+            const unmappedError = {
+                kind: SERVER_VIOLATION_ERROR_KIND,
+                message: violation.message,
+                violation,
+            };
+            errors.push(unmappedError);
+        }
+    }
+    return errors;
+};
+const createFallbackErrors = (error) => {
+    const queryError = isQueryErrorResponse(error) ? error : createQueryErrorResponse(error);
+    if (queryError.isList) {
+        return queryError.errors.map((item) => ({ kind: SERVER_ERROR_KIND, message: item.message }));
+    }
+    return [{ kind: SERVER_ERROR_KIND, message: queryError.error.message }];
+};
+/** Splits a property path like `items[2].name` or `translations['de'].title` into its segments. */
+const parsePropertyPath = (path) => {
+    return path
+        .replace(/\[(['"]?)([^\]]*?)\1\]/g, '.$2')
+        .split('.')
+        .filter((segment) => segment.length > 0);
+};
+const resolveFieldTreePath = (fieldTree, path) => {
+    let current = fieldTree;
+    for (const segment of parsePropertyPath(path)) {
+        if (current === null || (typeof current !== 'object' && typeof current !== 'function')) {
+            return null;
+        }
+        current = current[segment];
+    }
+    // A field tree node is callable (calling it returns the field state) — anything else means the
+    // path left the tree (e.g. an index past the array's current length).
+    return typeof current === 'function' ? current : null;
+};
+
+// Shared core for the query-backed async validators (`validateWithQuery` /
+// `validateWithV2Query`). Everything except how the query is executed — the `factory` that turns
+// the debounced params into a `Resource` — is identical between the v2 and v3 variants, so it is
+// factored here and imported by both. This module is intentionally NOT part of the `http` barrel;
+// it is internal plumbing consumed by direct path (the legacy variant already imports from `http`).
+/** Default debounce (ms) applied before a validate request runs, mirroring `selectOptionsFrom*Query`. */
+const DEFAULT_QUERY_VALIDATION_DEBOUNCE = 300;
+/**
+ * Turns a failed validate request into field errors — the default `onError` mapping shared by both
+ * validators. Reuses the existing `mapViolationsToFormErrors` bridge: a `422` violation list is
+ * resolved onto the child fields by `propertyPath`, while a network / non-violation error degrades
+ * to a non-swallowed form-level error. A caller-supplied `mapViolations` overrides only the
+ * violation → error step (it receives the already-extracted violations).
+ */
+const mapQueryValidationError = (error, ctx, mapViolations) => {
+    // Angular's `resource()` wraps a thrown non-`Error` (our `QueryErrorResponse` / `HttpErrorResponse`)
+    // into an `Error` and stashes the original on `.cause`, so unwrap it before extraction.
+    const cause = error instanceof Error && error.cause !== undefined ? error.cause : error;
+    if (mapViolations) {
+        return mapViolations(extractFormViolations(cause), ctx);
+    }
+    // `ctx.fieldTree` is the (read-only) tree of the validated field; `propertyPath`s resolve against
+    // it. The cast bridges `ReadonlyFieldTree` → `FieldTree` — `mapViolationsToFormErrors` only walks
+    // and reads the tree, never mutates it.
+    return mapViolationsToFormErrors({ fieldTree: ctx.fieldTree, error: cause });
+};
+/**
+ * Binds a query-backed async validator to `path` via `validateAsync`. Success (`204` / any `2xx`
+ * with no violation body) reports no errors; a failed request is mapped by
+ * {@link mapQueryValidationError}. Async validation only runs once the field's synchronous
+ * validators pass and while `when` holds — signal forms feeds the `factory` `undefined` params when
+ * the request shouldn't run, so the resource stays idle.
+ */
+const applyQueryAsyncValidator = (path, config) => {
+    validateAsync(path, {
+        params: config.params,
+        debounce: config.debounce ?? DEFAULT_QUERY_VALIDATION_DEBOUNCE,
+        factory: config.factory,
+        when: config.when,
+        onSuccess: () => null,
+        onError: (error, ctx) => mapQueryValidationError(error, ctx, config.mapViolations),
+    });
+};
+
+/**
+ * Binds a query-backed async validator to a signal-forms field, adapting a **legacy v2**
+ * `@ethlete/query` query into what `validateAsync` consumes — the `V2QueryClient` counterpart of
+ * {@link validateWithQuery}, so apps that haven't migrated yet can still validate against the
+ * server. The query runs through the client (bearer auth, base route, caching, Symfony error
+ * normalization), where a raw `httpResource` would fire unauthenticated and bypass the pipeline.
+ *
+ * The query is prepared and executed (debounced) as the field value changes, only after the
+ * field's synchronous validators pass. A `204` / successful response reports no errors; a
+ * `422 FormViolationListView` maps each violation onto its child field by `propertyPath`; a
+ * network / other error degrades to a non-swallowed form-level error.
+ *
+ * Call it from a schema definition, the same place you'd call `validateAsync`:
+ *
+ * ```ts
+ * const schema = schema<OpportunityEmail>((p) => {
+ *   validateWithV2Query(p, {
+ *     queryCreator: postOpportunityEmailValidate, // hubApiClient.post({ ... })
+ *     args: (ctx) => ({ pathParams: { opportunityId }, body: { ...ctx.value() } }),
+ *   });
+ * });
+ * ```
+ */
+const validateWithV2Query = (path, config) => {
+    applyQueryAsyncValidator(path, {
+        params: config.args,
+        debounce: config.debounce,
+        when: config.when,
+        mapViolations: config.mapViolations,
+        factory: (params) => resource({
+            params: () => params(),
+            loader: ({ params: prepareArgs, abortSignal }) => {
+                // Prepared per request — v2 caches by the prepared args, so a fresh `prepare()` is the
+                // legacy idiom (the sibling `selectOptionsFromV2Query` does the same via `queryComputed`).
+                const query = config.queryCreator.prepare(prepareArgs);
+                abortSignal.addEventListener('abort', () => query.abort());
+                query.execute();
+                // Resolve once the query settles. A failure is thrown so it lands in `onError`, where the
+                // violations are mapped onto the fields; the underlying `HttpErrorResponse` is thrown so
+                // `extractFormViolations` can unwrap the 422 body.
+                return firstValueFrom(query.state$.pipe(filter((state) => isQueryStateSuccess(state) || isQueryStateFailure(state)), take(1))).then((state) => {
+                    if (isQueryStateFailure(state)) {
+                        throw state.error.httpErrorResponse;
+                    }
+                    return state.response;
+                });
+            },
+        }),
+    });
+};
+
 const generateUuid = () => randomId();
 const createQueryRepository = (config) => {
     const cache = new Map();
@@ -5258,6 +5472,74 @@ const createPatchQuery = createQueryTemplate('PATCH');
 /** A query creator that creates a secure PATCH query (requires authentication) */
 const createSecurePatchQuery = createSecureQueryTemplate('PATCH');
 
+/**
+ * Executes the query and resolves once that execution has settled (response or error received).
+ * The returned snapshot is frozen to the awaited execution, so a later execution can't swap the
+ * `response()` / `error()` you read from it.
+ *
+ * Designed for imperative flows that need a mutation's outcome in place — e.g. a signal-forms
+ * `submit()` action mapping server violations onto the form via `mapViolationsToFormErrors`.
+ *
+ * The promise stays pending if the execution is cancelled (e.g. `reset()`) and the query is never
+ * executed again — the snapshot settles with whichever execution completes next.
+ */
+const executeUntilSettled = async (query, executeArgs) => {
+    query.execute(executeArgs);
+    const snapshot = query.createSnapshot();
+    await firstValueFrom(snapshot.isAlive.asObservable().pipe(filter((isAlive) => !isAlive)));
+    return snapshot;
+};
+
+/**
+ * Binds a query-backed async validator to a signal-forms field, adapting an `@ethlete/query` v3
+ * query into what `validateAsync` consumes. The query runs through the query client — so bearer
+ * auth, base route, caching and Symfony error normalization all apply — where a raw `httpResource`
+ * would fire unauthenticated and bypass the pipeline.
+ *
+ * On the current v3 `QueryClient` / `createPostQuery` creators; the `validateWithV2Query` twin
+ * covers the legacy `V2QueryClient`. The query is created once and re-executed (debounced) as the
+ * field value changes, only after the field's synchronous validators pass. A `204` / successful
+ * response reports no errors; a `422 FormViolationListView` maps each violation onto its child
+ * field by `propertyPath`; a network / other error degrades to a non-swallowed form-level error.
+ *
+ * Call it from a schema definition, the same place you'd call `validateAsync`:
+ *
+ * ```ts
+ * const schema = schema<OpportunityEmail>((p) => {
+ *   validateWithQuery(p, {
+ *     queryCreator: postOpportunityEmailValidate,
+ *     args: (ctx) => ({ pathParams: { opportunityId }, body: { ...ctx.value() } }),
+ *   });
+ * });
+ * ```
+ */
+const validateWithQuery = (path, config) => {
+    applyQueryAsyncValidator(path, {
+        params: config.args,
+        debounce: config.debounce,
+        when: config.when,
+        mapViolations: config.mapViolations,
+        factory: (params) => {
+            // Created once, exactly like a query stack. A POST validate route doesn't auto-execute, so
+            // the resource loader drives it — each params change re-executes with the new args.
+            const query = config.queryCreator();
+            return resource({
+                params: () => params(),
+                loader: async ({ params: requestArgs }) => {
+                    const snapshot = await executeUntilSettled(query, { args: requestArgs });
+                    const error = snapshot.error();
+                    // A failed request (e.g. 422) is thrown so it lands in `onError`, where the violations are
+                    // mapped onto the fields. A `204` / success settles with no error and no violations.
+                    if (error) {
+                        throw error;
+                    }
+                    return snapshot.response() ?? undefined;
+                },
+            });
+        },
+    });
+};
+
 const setupLeaderElection = () => {
     const destroyRef = inject(DestroyRef);
     const channelName = 'ethlete-auth-leader';
@@ -7521,5 +7803,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, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, extractExpiresInSeconds, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryExecute, queryFeatureUsedMultipleTimes, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
+export { 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, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryExecute, queryFeatureUsedMultipleTimes, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
 //# sourceMappingURL=ethlete-query.mjs.map