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

package/generators/migrate-to-query-v3/legacy-prepare-migration.js

@@ -569,7 +569,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
             : `{\n  ${nextArgumentProperties.join(',\n  ')}\n}`;
     return `${creatorName}.prepare(${nextArgumentString})`;
 };
-const findQueryVariableNameForPrepareCall = (prepareCallNode, sourceFile) => {
+const findQueryVariableNameForPrepareCall = (prepareCallNode, _sourceFile) => {
     let parent = prepareCallNode.parent;
     while (parent) {
         if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {

package/generators/prep-for-query-v3/migration.js

@@ -58,7 +58,7 @@ function renameConflictingSymbols(tree) {
     // Log statistics
     if (updatedFiles.length > 0) {
         console.log(`\n📊 Renamed symbols in ${updatedFiles.length} files:`);
-        const hasRenames = Array.from(symbolUsageCounts.entries()).filter(([_, count]) => count > 0);
+        const hasRenames = Array.from(symbolUsageCounts.entries()).filter(([, count]) => count > 0);
         if (hasRenames.length > 0) {
             console.log('\n   Symbol usage counts:');
             hasRenames.forEach(([symbol, count]) => {
@@ -123,7 +123,7 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     }
     visit(sourceFile);
     // Update imports in @ethlete/query import declarations
-    const importReplacements = updateImports(sourceFile, content);
+    const importReplacements = updateImports(sourceFile);
     replacements.push(...importReplacements);
     // Count usages
     replacements.forEach((r) => {
@@ -138,7 +138,7 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     }
     return result;
 }
-function updateImports(sourceFile, content) {
+function updateImports(sourceFile) {
     const replacements = [];
     function visit(node) {
         if (ts.isImportDeclaration(node)) {

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.17",
+  "version": "6.0.0-next.19",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {
-    "@analogjs/vite-plugin-angular": "2.6.2",
-    "@angular/common": "22.0.5",
-    "@angular/core": "22.0.5",
-    "@angular/forms": "22.0.5",
-    "@angular/router": "22.0.5",
+    "@analogjs/vite-plugin-angular": "2.6.3",
+    "@angular/common": "22.0.7",
+    "@angular/core": "22.0.7",
+    "@angular/forms": "22.0.7",
+    "@angular/router": "22.0.7",
     "@ethlete/core": "^5.0.0-beta.11",
     "@ethlete/types": "^2.0.0-beta.4",
-    "@nx/devkit": "23.1.0-beta.7",
+    "@nx/devkit": "23.1.0",
     "rxjs": "7.8.2",
     "socket.io-client": "4.8.3",
     "typescript": "6.0.3",
-    "vite": "8.0.13"
+    "vite": "8.1.5"
   },
   "generators": "./generators/generators.json",
   "module": "fesm2022/ethlete-query.mjs",

package/types/ethlete-query.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, CreateEffectOptions } from '@angular/core';
+import { Signal, Injector, CreateComputedOptions, InjectionToken, TrackByFunction, PipeTransform, OnInit, OnDestroy, DestroyRef, EnvironmentInjector, ErrorHandler, WritableSignal, CreateEffectOptions, EnvironmentProviders } from '@angular/core';
 import * as _ethlete_core from '@ethlete/core';
 import { ProviderResult, RuntimeError } from '@ethlete/core';
 import * as rxjs from 'rxjs';
@@ -67,7 +67,7 @@ declare function mapToPaginated<T>(response: Paginated<T>): rxjs.OperatorFunctio
 /**
  * Use an other store to represent a property of the current entity.
  */
-declare const insertFrom: <OriginStoreType, OriginKeys extends keyof NonNullable<OriginStoreType>, SubStoreType extends NonNullable<OriginStoreType>[OriginKeys] extends Array<infer U> ? U : NonNullable<OriginStoreType>[OriginKeys], IdFn extends (value: NonNullable<OriginStoreType>) => EntityKey | EntityKey[], ComputedEntityType extends ReturnType<IdFn> extends Array<unknown> ? OriginStoreType : Omit<OriginStoreType, OriginKeys> & { [K in OriginKeys]: SubStoreType | null; }>(store: EntityStore<SubStoreType>, { for: key, id }: InsertFromConfig<OriginStoreType, OriginKeys, IdFn>) => rxjs.OperatorFunction<OriginStoreType, ComputedEntityType | null>;
+declare const insertFrom: <OriginStoreType, OriginKeys extends keyof NonNullable<OriginStoreType>, SubStoreType extends (NonNullable<OriginStoreType>[OriginKeys] extends Array<infer U> ? U : NonNullable<OriginStoreType>[OriginKeys]), IdFn extends (value: NonNullable<OriginStoreType>) => EntityKey | EntityKey[], ComputedEntityType extends (ReturnType<IdFn> extends Array<unknown> ? OriginStoreType : Omit<OriginStoreType, OriginKeys> & { [K in OriginKeys]: SubStoreType | null; })>(store: EntityStore<SubStoreType>, { for: key, id }: InsertFromConfig<OriginStoreType, OriginKeys, IdFn>) => rxjs.OperatorFunction<OriginStoreType, ComputedEntityType | null>;
 /**
  * Remove entities from a store based on a where function.
  */
@@ -223,7 +223,7 @@ declare const serializeBody: (body: unknown) => ArrayBuffer | URLSearchParams |
 declare const transformMethod: (config: {
     method: Method;
     transferVia?: "GET" | "POST";
-}) => "GET" | "POST" | "OPTIONS" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 declare const detectContentTypeHeader: (body: unknown) => string | null;
 declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
 declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
@@ -1159,7 +1159,7 @@ declare const castQueryCreatorTypes: <QC extends AnyV2QueryCreator, Arguments ex
 declare const computeQueryMethod: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: V2QueryClient;
-}) => "GET" | "POST" | "OPTIONS" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 declare const computeQueryBody: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: V2QueryClient;
@@ -1180,7 +1180,7 @@ declare const computeQueryQueryParams: (config: {
     client: V2QueryClient;
     args?: BaseArguments;
 }) => object | undefined;
-declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends T extends Paginated<infer X> ? X : never>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
+declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends (T extends Paginated<infer X> ? X : never)>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
     rawResponse: T;
     response: T;
     args: Args;
@@ -1298,7 +1298,7 @@ declare class V2QueryClient {
     _updateBaseRoute: (route: string) => void;
 }
 
-declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "OPTIONS" | "HEAD" | "GQL_QUERY";
+declare const v2ShouldCacheQuery: (method: Method) => method is "GET" | "HEAD" | "OPTIONS" | "GQL_QUERY";
 declare const v2BuildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;
 
 declare class QueryStore {
@@ -1582,7 +1582,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -1592,7 +1592,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -1880,7 +1880,7 @@ declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQuer
     get instance(): InfinityQueryOf<Q> | null;
     get data$(): rxjs.Observable<Q["response"]["arrayType"]>;
     data: _angular_core.Signal<Q["response"]["arrayType"]>;
-    static ngTemplateContextGuard<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
+    static ngTemplateContextGuard<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>>(_dir: InfinityQueryDirective<Q>, _ctx: unknown): _ctx is InfinityQueryContext<Q>;
     constructor();
     private _setupInfinityQuery;
     loadNextPage(): void;
@@ -1948,7 +1948,7 @@ declare class QueryDirective<Q extends QueryDirectiveType | null> {
     query: _angular_core.InputSignal<Q>;
     cache: _angular_core.InputSignal<boolean>;
     queryState: _angular_core.WritableSignal<_ethlete_query.V2QueryState<QueryDataOf<QueryOf<Q>>> | null>;
-    static ngTemplateContextGuard<Q extends QueryDirectiveType | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryDirectiveContext<Q>;
+    static ngTemplateContextGuard<Q extends QueryDirectiveType | null>(_dir: QueryDirective<Q>, _ctx: unknown): _ctx is QueryDirectiveContext<Q>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, { "query": { "alias": "etQuery"; "required": true; "isSignal": true; }; "cache": { "alias": "etQueryCache"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -2040,6 +2040,12 @@ type QueryDependencies = {
     ngErrorHandler: ErrorHandler;
     /** The http client */
     httpClient: HttpClient;
+    /**
+     * The DOM element of the component/directive that created the query, when it was created in an
+     * element (node) injection context. `null` for queries created in a root/environment context.
+     * Used only by the devtools "inspect" tool.
+     */
+    hostElement: HTMLElement | null;
 };
 declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;
 
@@ -2498,6 +2504,36 @@ type QueryRepositoryItem<TArgs extends QueryArgs> = {
     /** The request object */
     request: HttpRequest<TArgs>;
 };
+/**
+ * A read-only snapshot of a single cache entry, exposed via {@link QueryRepositorySubtle.cacheEntries}
+ * for devtools inspection. The raw cache `Map` is never exposed.
+ */
+type QueryRepositoryCacheEntry = {
+    /** The cache key of the entry. */
+    key: QueryKey;
+    /** Whether the entry belongs to a secure (authenticated) request. */
+    isSecure: boolean;
+    /** How many consumers currently hold a binding to the entry. */
+    consumerCount: number;
+    /** The underlying HTTP request. */
+    request: HttpRequest<QueryArgs>;
+};
+/**
+ * Advanced repository internals used by the query devtools. **Not part of the general public
+ * contract** — do not build application logic on top of these.
+ */
+type QueryRepositorySubtle = {
+    /** Returns a read-only snapshot of every entry currently held in the cache. */
+    cacheEntries: () => QueryRepositoryCacheEntry[];
+    /** A version counter bumped whenever the cache changes (bind / unbind / unbindAllSecure). */
+    cacheVersion: Signal<number>;
+    /**
+     * Destroys and removes a single cache entry by key, regardless of its consumers. Intended for
+     * devtools cache management — consumers still holding the query will get a fresh request on their
+     * next execution.
+     */
+    evict: (key: QueryKey) => void;
+};
 /**
  * The query repository is responsible for managing all requests and their consumers.
  * It will cache requests if they can be cached and reuse them if they are already cached.
@@ -2512,6 +2548,8 @@ type QueryRepository = {
     unbindAllSecure: () => void;
     /** Observable stream of repository events (errors, successes, etc.) */
     events$: Observable<QueryRepositoryEvent>;
+    /** Advanced repository internals used by the query devtools. */
+    subtle: QueryRepositorySubtle;
 };
 /** The key of a query (either a cache key for cacheable requests or a UUID for uncacheable requests) */
 type QueryKey = string;
@@ -2559,6 +2597,8 @@ type CreateQueryClientConfigOptions = {
 };
 type QueryClient = {
     repository: QueryRepository;
+    /** The base URL the client was configured with. */
+    baseUrl: string;
 };
 type QueryClientRef = ProviderResult<QueryClient>;
 type AnyCreateQueryClientResult = QueryClientRef;
@@ -2620,6 +2660,10 @@ type HttpRequestLoadingProgressState = {
     remainingTime: number | null;
 };
 type HttpRequest<TArgs extends QueryArgs> = {
+    /** The HTTP method of the request. */
+    method: QueryMethod;
+    /** The full URL of the request (base + path + query params). */
+    url: string;
     /** Executes the request */
     execute: (options?: {
         allowCache?: boolean;
@@ -2648,6 +2692,11 @@ type HttpRequest<TArgs extends QueryArgs> = {
      * staleness depends on wall-clock time rather than on any tracked signal.
      */
     isStale: () => boolean;
+    /**
+     * The timestamp (ms) at which the cached response goes stale, or `null` when the request is not
+     * cacheable / has no freshness window. Exposed for devtools freshness countdowns.
+     */
+    expiresAt: Signal<number | null>;
 };
 /** A custom error event since the Angular http client does not provide a specific event for errors */
 type HttpErrorEvent = {
@@ -2727,6 +2776,16 @@ type QuerySubtle<TArgs extends QueryArgs> = {
     destroy: () => void;
     /** Manually sets the response of the query. This will not trigger a new execution of the query. */
     setResponse: (response: ResponseType<TArgs>) => void;
+    /**
+     * Manually forces the loading state of the query. Overridden on the next execution. Intended for
+     * devtools / testing UI states — not for application logic.
+     */
+    setLoading: (loading: HttpRequestLoadingState | null) => void;
+    /**
+     * Manually forces the error state of the query. Overridden on the next execution. Intended for
+     * devtools / testing UI states — not for application logic.
+     */
+    setError: (error: QueryErrorResponse | null) => void;
     /** The currently underlying HTTP request of the query. Will be `null` if the query has never been executed. */
     request: ObservableSignal<HttpRequest<TArgs> | null>;
     /** The destroy reference used to clean up the query when it is no longer needed */
@@ -2798,7 +2857,7 @@ type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ?
 declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<any>) => options is CreateGqlQueryOptions<any>;
 declare const createGqlQuery: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryOptions<TArgs>) => _ethlete_query.Query<TArgs>;
 
-declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
+declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
 declare const shouldAutoExecuteGqlQuery: (method: GqlQueryMethod) => method is "QUERY";
 declare const getQueryFeatureUsage: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<any>) => QueryFeatureFlags;
 declare const applyQueryFeatures: <TArgs extends QueryArgs>(features: QueryFeature<TArgs>[], context: QueryFeatureContext<TArgs>) => void;
@@ -2998,7 +3057,7 @@ type PagedQueryStack<TQuery extends AnyNewQuery, TNormPagination extends Normali
 declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TNormPagination extends NormalizedPagination<unknown>>(options: CreatePagedQueryStackOptions<TArgs, TNormPagination>) => PagedQueryStack<Query<TArgs>, TNormPagination>;
 
 declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
-declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
+declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
 declare const buildQueryCacheKey: (route: string, args: RequestArgs<QueryArgs> | undefined) => string;
 
 type QueryContext = {
@@ -3082,6 +3141,7 @@ declare const QueryRuntimeErrorCode: {
     readonly TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC: 700;
     readonly INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701;
     readonly CIRCULAR_QUERY_DEPENDENCY: 800;
+    readonly QUERY_SEQUENCE_ALREADY_RUNNING: 900;
 };
 type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
 declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<0>;
@@ -3106,6 +3166,109 @@ declare const gqlDataPropertyMissingInResponse: () => RuntimeError<600>;
 declare const tokensNotAvailableInsideAuthAndExec: () => RuntimeError<700>;
 declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
 declare const circularQueryDependency: () => RuntimeError<800>;
+declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
+
+/** The last element of a tuple type — the response of the step a `.then()` callback follows. */
+type LastOf<T extends unknown[]> = T extends [...unknown[], infer L] ? L : never;
+/** The current lifecycle phase of a query sequence. */
+type QuerySequenceStatus = 'idle' | 'running' | 'success' | 'error';
+/** The args a sequence step supplies to its query — the same `{ args }` shape `query.execute()` takes. */
+type QuerySequenceStepArgs<TArgs extends QueryArgs> = {
+    args: RequestArgs<TArgs>;
+};
+/**
+ * The outcome of a settled {@link QuerySequence.run}.
+ *
+ * A discriminated union: on success `responses` is the fully-typed tuple of every step's response;
+ * on failure `failedAt` is the zero-based index of the step that errored and `error` is its
+ * normalized {@link QueryErrorResponse}. `snapshots` always holds the settled snapshots of every
+ * step that ran — up to and including the failing one.
+ */
+type QuerySequenceResult<TResponses extends unknown[]> = {
+    ok: true;
+    responses: TResponses;
+    snapshots: AnyQuerySnapshot[];
+} | {
+    ok: false;
+    failedAt: number;
+    error: QueryErrorResponse;
+    snapshots: AnyQuerySnapshot[];
+};
+/**
+ * An imperative waterfall of dependent queries — usually mutations (`POST`/`PUT`/`PATCH`/`DELETE`)
+ * where each call needs the previous call's response.
+ *
+ * Build the chain once (e.g. as a component field) with {@link querySequence} and `.then()`, then
+ * trigger it with {@link run}. Each step runs via `executeUntilSettled`, threading the previous
+ * step's response into the next; the first error aborts the rest. The progress signals mirror
+ * `createQueryStack`, so a template can drive a stepper without manual bookkeeping.
+ */
+type QuerySequence<TResponses extends unknown[]> = {
+    /**
+     * Appends a dependent step. `mapArgs` runs at {@link run} time and receives the previous step's
+     * (unwrapped, non-null on success) response plus the typed tuple of all responses so far, so a
+     * later step can still reach an earlier one's data.
+     */
+    then: <TArgs extends QueryArgs>(query: Query<TArgs>, mapArgs: (previousResponse: LastOf<TResponses>, responses: TResponses) => QuerySequenceStepArgs<TArgs>) => QuerySequence<[...TResponses, ResponseType<TArgs>]>;
+    /** The current lifecycle phase — `idle` before the first run, then `running` → `success` | `error`. */
+    status: Signal<QuerySequenceStatus>;
+    /** `true` while a run is in flight. */
+    running: Signal<boolean>;
+    /** The 1-based index of the in-flight step, or `0` when idle. */
+    currentStep: Signal<number>;
+    /** The static number of steps in the sequence. */
+    total: number;
+    /** The query objects backing each step, in order. Useful for devtools / advanced introspection. */
+    queries: AnyNewQuery[];
+    /** The error of the step that failed, or `null` while running / on success. */
+    error: Signal<QueryErrorResponse | null>;
+    /** The zero-based index of the step that failed, or `null` while running / on success. */
+    failedAt: Signal<number | null>;
+    /** The settled snapshots of every step that has run, grows as the waterfall progresses. */
+    snapshots: Signal<AnyQuerySnapshot[]>;
+    /**
+     * The resolved input args each step was run with, grows as the waterfall progresses. The value at
+     * index `i` is what {@link QuerySequence.then}'s `mapArgs` produced for step `i` at run time.
+     */
+    stepArgs: Signal<unknown[]>;
+    /** The responses of every step that has succeeded, grows as the waterfall progresses. */
+    responses: Signal<Partial<TResponses>>;
+    /**
+     * Runs every step in order, resolving once the waterfall settles.
+     *
+     * Resets the progress signals, then awaits each step in turn — stopping at the first error and
+     * resolving with `{ ok: false, failedAt, error }`, or `{ ok: true, responses }` when all steps
+     * succeed. Re-runnable (e.g. behind a retry button); throws {@link querySequenceAlreadyRunning}
+     * if a run is already in flight.
+     *
+     * Cancellation caveat (inherited from `executeUntilSettled`): if the host scope is destroyed
+     * mid-flight the in-flight query is torn down and this promise never settles.
+     */
+    run: () => Promise<QuerySequenceResult<TResponses>>;
+};
+/**
+ * Starts an imperative waterfall of dependent queries. Chain the remaining steps with `.then()`
+ * and trigger it with `.run()` — see {@link QuerySequence}.
+ *
+ * The seed step's `args` are produced lazily (at `run()` time), so the sequence can safely live as
+ * a component field while still reading current signal values on each run.
+ *
+ * @example
+ * ```ts
+ * readonly checkout = querySequence(this.createOrder, () => ({ args: { body: this.order() } }))
+ *   .then(this.createPayment, (order) => ({ args: { body: { orderId: order.id } } }))
+ *   .then(this.confirmOrder, (payment, [order]) => ({
+ *     args: { pathParams: { paymentId: payment.id }, body: { orderRef: order.id } },
+ *   }));
+ *
+ * async submit() {
+ *   const result = await this.checkout.run();
+ *   if (!result.ok) return this.handle(result.error);
+ *   const [order, payment, confirmation] = result.responses;
+ * }
+ * ```
+ */
+declare const querySequence: <TArgs extends QueryArgs>(query: Query<TArgs>, seedArgs: () => QuerySequenceStepArgs<TArgs>) => QuerySequence<[ResponseType<TArgs>]>;
 
 /** `kind` of a `ValidationError` created from a single server violation. */
 declare const SERVER_VIOLATION_ERROR_KIND = "etServerViolation";
@@ -3986,6 +4149,76 @@ type BearerAuthProviderRef<TBuilders extends readonly AnyQueryBuilder[] = readon
 type AnyCreateBearerAuthProviderResult = BearerAuthProviderRef<any, any, any>;
 type AnyBearerAuthProvider = NonNullable<ReturnType<AnyCreateBearerAuthProviderResult[1]>>;
 
+/**
+ * The kind of object a {@link QueryDevtoolsEntry} describes. Part of the devtools contract consumed
+ * by `<et-query-devtools>` — not a general-purpose query API.
+ */
+type QueryDevtoolsEntryKind = 'query' | 'query-stack' | 'paged-query-stack' | 'query-sequence' | 'auth-provider' | 'ws-client';
+/**
+ * Descriptive, mostly-static metadata about a registered devtools entry. The live, reactive state
+ * is read from the entry's {@link QueryDevtoolsEntry.handle} instead.
+ */
+type QueryDevtoolsEntryMeta = {
+    /** Display name of the owning query client, where known. */
+    clientName?: string;
+    /** Base URL of the owning query client, where known. */
+    clientBaseUrl?: string;
+    /** Human readable display name (e.g. an auth provider or web socket client name). */
+    name?: string;
+    /** The connection URL, for web socket clients. */
+    url?: string;
+    /** The GraphQL document string, for GraphQL queries. */
+    gqlQuery?: string;
+    /** Stringified route with path params rendered as `:param`, for queries. */
+    route?: string;
+    /** Human readable HTTP/GQL method, for queries (e.g. `GET`, `GQL QUERY`). */
+    method?: string;
+    /** The feature types applied at creation, for queries. */
+    featureTypes?: QueryFeatureType[];
+    /** The query config passed at creation, for queries. */
+    queryConfig?: QueryConfig;
+    /** The creator options passed at creation, for queries. */
+    creator?: CreateQueryCreatorOptions;
+    /** The owning client's repository, where known (queries and auth providers). */
+    repository?: QueryRepository;
+    /**
+     * The DOM element of the component/directive that created a query, when available. Used by the
+     * devtools "inspect" tool to map a query back to its place in the live UI.
+     */
+    element?: HTMLElement | null;
+};
+/**
+ * A single entry in the {@link queryDevtoolsEntries} registry. The `handle` is the live object
+ * (query, stack, sequence or auth provider) so its signals stay reactive when read by the UI.
+ */
+type QueryDevtoolsEntry = {
+    id: string;
+    kind: QueryDevtoolsEntryKind;
+    meta: QueryDevtoolsEntryMeta;
+    handle: unknown;
+    createdAt: number;
+};
+/**
+ * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
+ */
+declare const queryDevtoolsEntries: Signal<QueryDevtoolsEntry[]>;
+/**
+ * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
+ * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
+ * appear in the `<et-query-devtools>` panel.
+ *
+ * When omitted, all devtools instrumentation is a no-op — no references are retained and there is no
+ * runtime overhead — so it is safe to leave out of production builds.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideQueryDevtools()],
+ * });
+ * ```
+ */
+declare const provideQueryDevtools: () => EnvironmentProviders;
+
 type TransformedGqlQuery = {
     query: string;
     variables?: string;
@@ -4075,6 +4308,23 @@ declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageEnPipe, "parseHttpErrorCodeToMessageEn", true>;
 }
 
+/** A single message captured for the devtools web socket inspector. */
+type WebSocketDevtoolsMessage = {
+    id: number;
+    timestamp: number;
+    room: string;
+    event: string;
+    data: unknown;
+};
+/**
+ * The live handle a web socket client registers with the devtools. Read by the `<et-query-devtools>`
+ * Sockets tab. Not part of the general public contract.
+ */
+type WebSocketDevtoolsHandle = {
+    connected: Signal<boolean>;
+    rooms: Signal<string[]>;
+    messages: Signal<WebSocketDevtoolsMessage[]>;
+};
 type CreateWebSocketClientTransport = 'polling' | 'websocket' | 'webtransport';
 type CreateWebSocketClientConfigOptions = {
     /** A unique name for the client */
@@ -4118,5 +4368,5 @@ type WebSocketClientResult<TMessageData extends SocketMessageView = SocketMessag
 type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientResult<TMessageData>;
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, 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 };
-export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthFeature, BearerAuthProvider, BearerAuthProviderFeatureContext, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientRef, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldOptions, QueryFilterConfig, QueryFormGroup, QueryFormGroupControls, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryKey, QueryMethod, QueryMockConfig, QueryOf, QueryParams, QueryParamsType, QueryPrepareFn, QueryRegistry, QueryRepository, QueryRepositoryDependencies, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRequestOptions, QueryResponseOf, QueryRouteOf, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QueryTrigger, RawResponseType, ReadonlyQuery, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientResult, WebSocketClientSubtle, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryExecute, queryFeatureUsedMultipleTimes, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthFeature, BearerAuthProvider, BearerAuthProviderFeatureContext, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ClearQueryArgs, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DestroyCleanupCallback, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteFactory, ExecuteQueryOptions, ExtractQueryArgs, ExtractQueryKey, Failure, FeatureRegistry, GQL, GqlQueryArgs, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlQueryMethod, GqlQueryTransport, GqlTransferOption, GqlTransformer, GqlVariablesType, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientRef, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldOptions, QueryFilterConfig, QueryFormGroup, QueryFormGroupControls, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryKey, QueryMethod, QueryMockConfig, QueryOf, QueryParams, QueryParamsType, QueryPrepareFn, QueryRegistry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QueryTrigger, RawResponseType, ReadonlyQuery, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RouteString, RouteType, RunQueryCreator, RunQueryExecuteOptions, SecureExecuteFactoryOptions, ServerValidationError, ServerViolationValidationError, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenExpirationWarningConfig, TokenExpirationWarningFeature, TokenRefreshEventData, TokenRefreshQueryBuilder, TokenRefreshQueryConfig, TokenResponse, TokenRevocationConfig, TokenRevocationFeature, TotalPagesExtractorOptions, TrackingConfig, TrackingEventDataMap, TrackingEventHandler, TrackingEventName, TrackingFeature, TransformedGqlQuery, V2CacheAdapterFn, V2PrepareArgsOf, V2QueryArgsOf, V2QueryClientConfig, V2QueryConfig, V2QueryState, V2RouteString, V2RouteType, ValidateWithQueryConfig, ValidateWithV2QueryConfig, WebSocketClient, WebSocketClientResult, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithMock, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };