@ethlete/query 6.0.0-next.37 → 6.0.0-next.39

package/types/ethlete-query.d.ts

@@ -9,7 +9,7 @@ import * as _angular_common_http from '@angular/common/http';
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpEvent, HttpStatusCode } from '@angular/common/http';
 import * as _ethlete_query from '@ethlete/query';
 import { NormalizedPagination, ContentfulGqlLikePaginated, DynLikePaginated, Paginated, GgLikePaginated, FormViolationListView, FormViolationView } from '@ethlete/types';
-import { FieldTree, ValidationError, PathKind, FieldContext, TreeValidationResult, SchemaPath, SchemaPathRules } from '@angular/forms/signals';
+import { FieldTree, ValidationError, TreeValidationResult, PathKind, FieldContext, SchemaPath, SchemaPathRules } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
 import { FormControl, FormGroup } from '@angular/forms';
 import { ToObservableOptions, ToSignalOptions } from '@angular/core/rxjs-interop';
@@ -951,6 +951,7 @@ declare const sumQueryDevtoolsStats: (handles: readonly (QueryDevtoolsStatsHandl
 
 type SetupQueryStateOptions<TArgs extends QueryArgs> = {
     transformResponse?: (rawResponse: RawResponseType<TArgs>) => ResponseType<TArgs>;
+    destroyRef?: DestroyRef;
     /**
      * The devtools stats recorder to feed from this state's executions, or nothing when the devtools are
      * not installed.
@@ -1011,10 +1012,18 @@ type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
     type: 'success';
     response: ResponseType<TArgs>;
 };
-type QueryExecutionStateFailure = {
+type QueryExecutionStateFailureWithNoResponse = {
     type: 'failure';
     error: QueryErrorResponse;
+    hasCachedResponse?: false;
 };
+type QueryExecutionStateFailureWithCachedResponse<TArgs extends QueryArgs> = {
+    type: 'failure';
+    error: QueryErrorResponse;
+    hasCachedResponse: true;
+    cachedResponse: ResponseType<TArgs>;
+};
+type QueryExecutionStateFailure<TArgs extends QueryArgs> = QueryExecutionStateFailureWithNoResponse | QueryExecutionStateFailureWithCachedResponse<TArgs>;
 type QueryExecutionStateLoadingWithNoResponse = {
     type: 'loading';
     hasCachedResponse: false;
@@ -1027,7 +1036,7 @@ type QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = {
     cachedResponse: ResponseType<TArgs>;
 };
 type QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithNoResponse | QueryExecutionStateLoadingWithCachedResponse<TArgs>;
-type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure | QueryExecutionStateLoading<TArgs>;
+type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure<TArgs> | QueryExecutionStateLoading<TArgs>;
 declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions<TArgs>) => QueryState<TArgs>;
 
 type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
@@ -1854,6 +1863,23 @@ type QueryMultiTabSyncConfig = {
     refreshOnMutation?: boolean | QuerySyncRefreshOnMutationConfig;
 };
 
+/** How a hold is requested, and how it reports back when it is taken away. */
+type QueryKeyLockHoldOptions = {
+    /**
+     * Takes the key from whoever holds it instead of queueing behind them, and preempts every request
+     * already queued for it. For the one case a queue cannot answer: a holder that stopped running -
+     * a frozen or suspended tab - keeps its lock while it does none of the work the lock stands for,
+     * and nothing it does not run can hand it over.
+     *
+     * The tab it is taken from hears about it through {@link onLost}.
+     */
+    steal?: boolean;
+    /**
+     * Called when another tab took this key over while this hold had it. Not called for a release of
+     * this tab's own, and not for a queued request that was aborted.
+     */
+    onLost?: () => void;
+};
 /** A single outstanding request for the lock of one key. */
 type QueryKeyLockHold = {
     /**
@@ -1882,7 +1908,7 @@ type QueryKeyLockState = 'holder' | 'standby';
  */
 type QueryKeyLockManager = {
     /** Requests the lock for `key`. */
-    hold: (key: string) => QueryKeyLockHold;
+    hold: (key: string, options?: QueryKeyLockHoldOptions) => QueryKeyLockHold;
     /**
      * Whether the Web Locks API backs this manager. When `false` every caller is immediately the
      * holder of every key, which degrades to "every tab does the work itself".
@@ -2609,7 +2635,7 @@ type RawResponseType<T extends QueryArgs | null> = T extends QueryArgs ? T['rawR
 type PathParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['pathParams'] : never;
 type QueryParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['queryParams'] : never;
 type BodyType<T extends QueryArgs | null> = T extends QueryArgs ? T['body'] : never;
-type RequestArgs<T extends QueryArgs | null> = T extends QueryArgs ? Omit<T, 'response'> : never;
+type RequestArgs<T extends QueryArgs | null> = T extends QueryArgs ? Omit<T, 'rawResponse' | 'response'> : never;
 /**
  * The empty request-args object, typed to satisfy `RequestArgs<TArgs>` for a query that takes no
  * arguments - its `QueryArgs` is just `{ response: T }`, so `RequestArgs` resolves to `{}`.
@@ -2634,8 +2660,7 @@ type QueryBase<TArgs extends QueryArgs> = {
     args: ObservableSignal<RequestArgs<TArgs> | null>;
     /**
      * The latest response of the query. Will be `null` if the query has never been executed.
-     * Responses are cached until a new response is received.
-     * If a response is present but the next execution of the query fails, the response will be set to `null` again.
+     * Responses are cached until a new response is received, including when a re-execution fails.
      */
     response: ObservableSignal<ResponseType<TArgs> | null>;
     /** The latest Angular HTTP client native http event that occurred during the last execution of the query. Will be `null` if no event occurred. */
@@ -2971,6 +2996,203 @@ type CreateIndexedDbQueryPersistenceAdapterOptions = {
  */
 declare const createIndexedDbQueryPersistenceAdapter: (options: CreateIndexedDbQueryPersistenceAdapterOptions) => QueryPersistenceAdapter;
 
+/** The current lifecycle phase of a query batch. */
+type QueryBatchStatus = 'idle' | 'running' | 'success' | 'partial' | 'error' | 'cancelled';
+type QueryBatchItemSuccess<TItem, TArgs extends QueryArgs> = {
+    status: 'success';
+    index: number;
+    item: TItem;
+    args: RequestArgs<TArgs>;
+    response: ResponseType<TArgs>;
+};
+type QueryBatchItemError<TItem, TArgs extends QueryArgs> = {
+    status: 'error';
+    index: number;
+    item: TItem;
+    args: RequestArgs<TArgs>;
+    error: QueryErrorResponse;
+};
+/** An item whose `args` function returned `null` - it was never sent. */
+type QueryBatchItemSkipped<TItem> = {
+    status: 'skipped';
+    index: number;
+    item: TItem;
+};
+/** An item that was still queued when the run was cancelled or stopped by `stopOnError`. */
+type QueryBatchItemCancelled<TItem> = {
+    status: 'cancelled';
+    index: number;
+    item: TItem;
+};
+type QueryBatchItemResult<TItem, TArgs extends QueryArgs> = QueryBatchItemSuccess<TItem, TArgs> | QueryBatchItemError<TItem, TArgs> | QueryBatchItemSkipped<TItem> | QueryBatchItemCancelled<TItem>;
+/** The outcome of a settled {@link QueryBatch.run} or {@link QueryBatch.retryFailed}. */
+type QueryBatchResult<TItem, TArgs extends QueryArgs> = {
+    /** `true` when every item either succeeded or was skipped, and nothing was left unattempted. */
+    ok: boolean;
+    /** `true` if the run stopped early - through `cancel()` or `stopOnError`. */
+    cancelled: boolean;
+    /** Every item's outcome, in input order. */
+    results: QueryBatchItemResult<TItem, TArgs>[];
+    succeeded: QueryBatchItemSuccess<TItem, TArgs>[];
+    failed: QueryBatchItemError<TItem, TArgs>[];
+    skipped: QueryBatchItemSkipped<TItem>[];
+    notAttempted: QueryBatchItemCancelled<TItem>[];
+};
+/**
+ * Runs one mutation over many items with a bounded number of requests in flight, keeping a per-item
+ * outcome so a partial failure stays recoverable.
+ *
+ * Built by {@link createQueryBatch}. Unlike a query stack the queries are not kept around: each item
+ * gets a query, runs it, and the query is destroyed once it settles - so a batch of 5000 items holds
+ * `concurrency` queries at a time, not 5000.
+ */
+type QueryBatch<TItem, TArgs extends QueryArgs> = {
+    /** The current lifecycle phase - `idle` before the first run, then `running` → the settled phase. */
+    status: Signal<QueryBatchStatus>;
+    /** `true` while a run is in flight. */
+    running: Signal<boolean>;
+    /** How many items the current (or last) run covers. */
+    total: Signal<number>;
+    /** How many items have settled in any way - success, error, skipped or cancelled. */
+    completed: Signal<number>;
+    /** How many requests are in flight right now, at most `concurrency`. */
+    inFlight: Signal<number>;
+    succeeded: Signal<number>;
+    failed: Signal<number>;
+    skipped: Signal<number>;
+    /**
+     * How far the run has got, as a percentage (`0`-`100`) so it can be bound straight to
+     * `<et-progress-bar [value]>` or a button's `[progress]`. `0` before the first run.
+     */
+    progress: Signal<number>;
+    /**
+     * Items settling per second, averaged over the current (or last) run - the batch counterpart of a
+     * transfer's `speed`. `null` until enough items have settled to measure.
+     */
+    itemsPerSecond: Signal<number | null>;
+    /**
+     * Roughly how much longer the run needs, in milliseconds: the items still outstanding at the
+     * measured {@link QueryBatch.itemsPerSecond}. `null` while there is no throughput to extrapolate
+     * from and once nothing is left, so a template can fall back to an indeterminate label.
+     *
+     * It re-estimates on every settled item, and a batch whose items differ wildly in cost will move
+     * around a lot - treat it as an estimate, not a countdown.
+     */
+    remainingTime: Signal<number | null>;
+    /** Every settled item's outcome so far, in input order. Grows as the run progresses. */
+    results: Signal<QueryBatchItemResult<TItem, TArgs>[]>;
+    /** The errors of every failed item so far. */
+    errors: Signal<QueryErrorResponse[]>;
+    /** The items that failed, for a "3 of 500 could not be updated" list. */
+    failedItems: Signal<TItem[]>;
+    /**
+     * Runs the mutation once per item. Cold: nothing is sent until it is subscribed to, and it emits
+     * the result once and completes when the batch settles.
+     *
+     * Subscribing resets the previous run's results. Errors with {@link queryBatchAlreadyRunning} if a
+     * run is still in flight. A failing item does not abort the rest unless `stopOnError` is set.
+     */
+    run: (items: readonly TItem[]) => Observable<QueryBatchResult<TItem, TArgs>>;
+    /**
+     * Re-runs only the items that did not succeed - the failed ones plus anything left unattempted by
+     * a `cancel()` or `stopOnError`. Successful items are never sent twice, which is what makes this
+     * safe to put behind a retry button in a bulk edit. Cold, like {@link QueryBatch.run}.
+     */
+    retryFailed: () => Observable<QueryBatchResult<TItem, TArgs>>;
+    /**
+     * Stops scheduling further items. Requests already in flight are **not** aborted - a mutation the
+     * server may have already applied must still be recorded - so they settle into the results as
+     * normal and the run emits once they do.
+     *
+     * Unsubscribing from the run does abort everything in flight, which for a mutation is rarely what
+     * you want. Prefer this.
+     */
+    cancel: () => void;
+    /** Clears the results and returns to `idle`. Ignored while a run is in flight. */
+    reset: () => void;
+};
+type AnyQueryBatch = QueryBatch<any, any>;
+type AnyQueryBatchItemResult = QueryBatchItemResult<any, any>;
+/**
+ * The stable holder the devtools registry keeps as a batch entry's handle, and which every one of the
+ * batch's item queries is attributed to. Read `current` to reach the batch itself.
+ *
+ * Indirect because it has to exist before the {@link QueryBatch} it points at does: the code that
+ * creates an item query closes over the owner while the batch object is still being built.
+ */
+type QueryBatchDevtoolsHandle = {
+    current: AnyQueryBatch;
+};
+type CreateQueryBatchOptions<TCreator extends AnyQueryCreator, TItem> = {
+    /** The query creator to run per item - usually a `POST`/`PUT`/`PATCH`/`DELETE`. */
+    queryCreator: TCreator;
+    /**
+     * Builds one item's request args. Return `null` to skip the item without sending anything - it is
+     * recorded as `skipped` rather than as a failure.
+     */
+    args: (item: TItem, index: number) => RequestArgs<QueryArgsOf<TCreator>> | null;
+    /**
+     * How many requests may be in flight at once.
+     *
+     * @default 4
+     */
+    concurrency?: number;
+    /**
+     * If `true`, the first failure stops the batch: everything still queued is recorded as `cancelled`
+     * and the requests already in flight are left to settle.
+     *
+     * @default false
+     */
+    stopOnError?: boolean;
+    /**
+     * Features applied to every query in the batch.
+     *
+     * @throws If the `withArgs` feature is used - args come from the `args` option.
+     */
+    features?: QueryFeature<any>[];
+    /** Passed to each `execute()`. Only meaningful when batching cacheable (`GET`-like) requests. */
+    allowCache?: boolean;
+    /**
+     * Called as each item settles, before the run emits. Use it to stream progress into the UI -
+     * removing a row the moment its update lands, say.
+     */
+    onItemSettled?: (result: QueryBatchItemResult<TItem, QueryArgsOf<TCreator>>) => void;
+};
+/**
+ * Runs the same mutation over a list of items - the bulk edit / bulk delete shape - with a bounded
+ * number of requests in flight and a per-item outcome.
+ *
+ * Where a query stack fans a reactive read out over many arg sets and keeps every query alive, a
+ * batch is imperative and disposable: it is triggered by a button, it tolerates a partial failure,
+ * and it destroys each query as soon as that item settles.
+ *
+ * Call it from an injection context; the host's destruction stops an in-flight run.
+ *
+ * @example
+ * ```ts
+ * protected archivePosts = createQueryBatch({
+ *   queryCreator: patchPost,
+ *   args: (post: Post) => ({ pathParams: { id: post.id }, body: { archived: true } }),
+ *   concurrency: 6,
+ * });
+ *
+ * archiveSelected() {
+ *   this.archivePosts
+ *     .run(this.selection())
+ *     .pipe(tap((result) => result.ok || this.toast.error(`${result.failed.length} failed`)))
+ *     .subscribe();
+ * }
+ * ```
+ *
+ * ```html
+ * <button et-button [loading]="archivePosts.running()" [progress]="archivePosts.progress()">Archive</button>
+ * @if (archivePosts.failed()) {
+ *   <button (click)="retry()">Retry {{ archivePosts.failed() }} failed</button>
+ * }
+ * ```
+ */
+declare const createQueryBatch: <TCreator extends AnyQueryCreator, TItem>(options: CreateQueryBatchOptions<TCreator, TItem>) => QueryBatch<TItem, QueryArgsOf<TCreator>>;
+
 declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
 declare const shouldCacheQuery: (method: QueryMethod) => method is "GET" | "OPTIONS" | "HEAD";
 declare const buildQueryCacheKey: (route: string, args: RequestArgs<QueryArgs> | undefined) => string;
@@ -3141,6 +3363,8 @@ declare const QueryRuntimeErrorCode: {
     readonly INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701;
     readonly CIRCULAR_QUERY_DEPENDENCY: 800;
     readonly QUERY_SEQUENCE_ALREADY_RUNNING: 900;
+    readonly QUERY_BATCH_ALREADY_RUNNING: 910;
+    readonly QUERY_BATCH_WITH_ARGS_USED: 911;
     readonly LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT: 950;
     readonly LEGACY_QUERY_STATE_ALREADY_HAS_KEY: 951;
     readonly LEGACY_QUERY_STATE_DOES_NOT_CONTAIN_KEY: 952;
@@ -3175,6 +3399,8 @@ declare const invalidStateInsideSecureExecuteFactory: () => RuntimeError<701>;
 declare const circularQueryDependency: () => RuntimeError<800>;
 declare const legacyPrepareWithoutInjectionContext: (creatorName: string | undefined, method?: "prepare" | "createSubject" | "createSignal") => RuntimeError<950>;
 declare const querySequenceAlreadyRunning: () => RuntimeError<900>;
+declare const queryBatchAlreadyRunning: () => RuntimeError<910>;
+declare const queryBatchWithArgsUsed: () => RuntimeError<911>;
 
 /** 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;
@@ -3224,6 +3450,13 @@ type QuerySequence<TResponses extends unknown[]> = {
     running: Signal<boolean>;
     /** The 1-based index of the in-flight step, or `0` when idle. */
     currentStep: Signal<number>;
+    /** How many steps have settled - the successful ones plus the failing one. */
+    completed: Signal<number>;
+    /**
+     * How far the waterfall has got, as a percentage (`0`-`100`) so it can be bound straight to
+     * `<et-progress-bar [value]>` or a button's `[progress]`. A run that fails stops where it stopped.
+     */
+    progress: 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. */
@@ -3514,6 +3747,105 @@ declare const transformPaginatedResponse: <T extends ({
 } | null)[]>(responses: T) => NonNullable<NonNullable<T[0]>["items"]>;
 declare const createQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TDeps extends () => any, TTransform = (ResponseType<TArgs> | null)[]>(options: CreateQueryStackOptions<TCreator, TDeps, TTransform>) => QueryStack<RunQueryCreator<TCreator>, TCreator, TTransform>;
 
+/** Config for {@link createQuerySubmission}. */
+type CreateQuerySubmissionConfig<TCreator extends AnyQueryCreator, TModel> = {
+    /**
+     * The mutation to submit through (e.g. a `createPostQuery` creator). Like a query stack, the query
+     * is created **once**; its args come from each submit rather than from a `withArgs()` feature.
+     */
+    queryCreator: TCreator;
+    /**
+     * Builds the request args from the submitted form value. Return `null` to abort the submit without
+     * a request - for a value the API has no route for yet, say. Omit it for a route that takes none.
+     */
+    args?: (value: TModel, field: FieldTree<TModel>) => RequestArgs<QueryArgsOf<TCreator>> | null;
+    /**
+     * Runs after the request succeeded, before the action resolves and the form leaves its submitting
+     * state - notify, close the overlay, navigate.
+     */
+    onSuccess?: (response: NonNullable<ResponseType<QueryArgsOf<TCreator>>>, field: FieldTree<TModel>) => void;
+    /**
+     * Rewrites a violation's property path before it is resolved against the field tree - use it when
+     * the API's payload shape differs from the form model. Return `null` to leave the violation
+     * unmapped, so it becomes a form-level error.
+     */
+    rewritePath?: (path: string, violation: FormViolationView) => string | null;
+    /**
+     * Override the default violation → error mapping. Receives the failed request's error; return the
+     * errors to report. Defaults to `mapViolationsToFormErrors` against the submitted field.
+     */
+    mapViolations?: (error: unknown, field: FieldTree<TModel>) => TreeValidationResult;
+};
+type QuerySubmissionRef<TCreator extends AnyQueryCreator, TModel> = {
+    /** The query the submission runs, for an error banner or a retry - never execute it yourself. */
+    query: Query<QueryArgsOf<TCreator>>;
+    /** The signal form `submission.action`. */
+    action: (field: FieldTree<TModel>) => Promise<TreeValidationResult>;
+};
+/**
+ * Builds a signal form's `submission.action` around a mutation: submitting executes the query with
+ * args derived from the form's value, waits for it to settle, and maps a failed request's violations
+ * back onto the fields that caused them. `form().submitting()` therefore covers the whole round trip.
+ *
+ * This is the submit-time counterpart to {@link validateWithQuery}. The query's args come from the
+ * submitted value rather than a `withArgs()` feature, which also means the query no longer reads the
+ * form it belongs to - so it can be declared before it, and no derivation runs per keystroke.
+ *
+ * ```ts
+ * protected createPost = createQuerySubmission({
+ *   queryCreator: postPost,
+ *   args: (value) => ({ body: value }),
+ *   onSuccess: (post) => this.router.navigate(['/posts', post.id]),
+ * });
+ *
+ * protected form = form(this.model, postSchema, {
+ *   submission: { action: this.createPost.action },
+ * });
+ * ```
+ *
+ * ```html
+ * <form [etForm]="form">…</form>
+ * <et-query-error [error]="createPost.query.error()" [query]="createPost.query" />
+ * ```
+ *
+ * Call it from an injection context.
+ */
+declare const createQuerySubmission: <TCreator extends AnyQueryCreator, TModel>(config: CreateQuerySubmissionConfig<TCreator, TModel>) => QuerySubmissionRef<TCreator, TModel>;
+
+type InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs> & {
+    authProvider: AnyCreateBearerAuthProviderResult;
+};
+declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalSecureCreateQueryCreatorOptions<TArgs>) => QueryCreator<TArgs>;
+
+type CreateSecureQueryOptions<TArgs extends QueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creatorInternals'> & {
+    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
+};
+declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => _ethlete_query.Query<TArgs>;
+
+type CreateSecureQueryExecuteOptions<TArgs extends QueryArgs> = Omit<CreateQueryExecuteOptions<TArgs>, 'creatorInternals'> & {
+    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
+};
+declare const createSecureExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateSecureQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;
+
+type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
+    authProvider: AnyBearerAuthProvider;
+    deps: QueryDependencies;
+    state: QueryState<TArgs>;
+    /**
+     * Whether the query runs itself rather than only on an explicit `execute()` - the same condition
+     * `maybeExecute` and the `withArgs` feature use. Only those are re-run once a new session starts;
+     * re-firing a mutation on the next login would repeat it behind the user's back.
+     */
+    autoExecutes: boolean;
+    /**
+     * Hands the execution over to the concrete query implementation. `executeArgs.args.headers` is a
+     * provider function, not resolved headers - it must be passed through to the repository as-is, or
+     * the request freezes the access token it was first built with.
+     */
+    transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> | undefined, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
+};
+declare const createSecureExecuteFactory: <TArgs extends QueryArgs>(options: SecureExecuteFactoryOptions<TArgs>) => InternalQueryExecute<TArgs>;
+
 /** Config for {@link validateWithQuery}. */
 type ValidateWithQueryConfig<TCreator extends AnyQueryCreator, TValue, TPathKind extends PathKind> = {
     /**
@@ -3566,40 +3898,6 @@ type ValidateWithQueryConfig<TCreator extends AnyQueryCreator, TValue, TPathKind
  */
 declare const validateWithQuery: <TCreator extends AnyQueryCreator, TValue, TPathKind extends PathKind = PathKind.Root>(path: SchemaPath<TValue, SchemaPathRules.Supported, TPathKind>, config: ValidateWithQueryConfig<TCreator, TValue, TPathKind>) => void;
 
-type InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs> & {
-    authProvider: AnyCreateBearerAuthProviderResult;
-};
-declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalSecureCreateQueryCreatorOptions<TArgs>) => QueryCreator<TArgs>;
-
-type CreateSecureQueryOptions<TArgs extends QueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creatorInternals'> & {
-    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
-};
-declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => _ethlete_query.Query<TArgs>;
-
-type CreateSecureQueryExecuteOptions<TArgs extends QueryArgs> = Omit<CreateQueryExecuteOptions<TArgs>, 'creatorInternals'> & {
-    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
-};
-declare const createSecureExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateSecureQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;
-
-type SecureExecuteFactoryOptions<TArgs extends QueryArgs> = {
-    authProvider: AnyBearerAuthProvider;
-    deps: QueryDependencies;
-    state: QueryState<TArgs>;
-    /**
-     * Whether the query runs itself rather than only on an explicit `execute()` - the same condition
-     * `maybeExecute` and the `withArgs` feature use. Only those are re-run once a new session starts;
-     * re-firing a mutation on the next login would repeat it behind the user's back.
-     */
-    autoExecutes: boolean;
-    /**
-     * Hands the execution over to the concrete query implementation. `executeArgs.args.headers` is a
-     * provider function, not resolved headers - it must be passed through to the repository as-is, or
-     * the request freezes the access token it was first built with.
-     */
-    transformAuthAndExec: (executeArgs: QueryExecuteArgs<TArgs> | undefined, executeState: ReturnType<typeof setupQueryExecuteState>) => void;
-};
-declare const createSecureExecuteFactory: <TArgs extends QueryArgs>(options: SecureExecuteFactoryOptions<TArgs>) => InternalQueryExecute<TArgs>;
-
 type BearerAuthProviderTokens = {
     accessToken: string;
     refreshToken: string;
@@ -3840,7 +4138,11 @@ type BearerAuthMultiTabSyncConfig = {
     leaderElection?: boolean;
 };
 type BearerAuthMultiTabSyncFeature = {
-    /** Whether this tab is the one performing the automatic token refresh. */
+    /**
+     * Whether this tab is the one performing the automatic token refresh. It follows the user: a tab
+     * that becomes hidden gives the leadership up, a tab that becomes visible claims it, and a tab that
+     * stopped running has it taken off it.
+     */
     isLeader: Signal<boolean>;
     /** How many tabs of this app currently take part in the election. Telemetry only. */
     instanceCount: Signal<number>;
@@ -3855,7 +4157,8 @@ type BearerAuthMultiTabSyncFeature = {
 /**
  * Keeps one browser session consistent across the user's tabs: a login in one tab logs the others in,
  * a logout logs them out, and only one tab (the leader) performs the automatic token refresh so a
- * single-use refresh token is not spent twice.
+ * single-use refresh token is not spent twice. The leadership follows the tab the user is looking at,
+ * because a hidden tab has its timers throttled and a frozen one runs none at all.
  *
  * Off by default - a single-tab app, a kiosk or an embedded webview ships neither the
  * `BroadcastChannel` sync nor the Web Locks leader election without it. Degrades to "this tab is the
@@ -4245,6 +4548,14 @@ type BearerAuthRefreshCoordination = {
     request: () => void;
     /** Emits in the leader tab whenever another tab asked for a refresh. */
     requests$: Observable<void>;
+    /**
+     * Tells the other tabs that a refresh started here. It is what makes {@link request} more than a
+     * message into the void: a follower that gets no answer takes the refresh over itself, so a leader
+     * that is working on one has to say so.
+     */
+    announceStart: () => void;
+    /** Emits whenever another tab announced that it started a refresh. */
+    starts$: Observable<void>;
 };
 /**
  * How the tabs of one session keep a single idea of when the user was last active. Contributed by
@@ -4789,7 +5100,7 @@ type QueryDevtoolsFormHandle = {
  * 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' | 'query-form';
+type QueryDevtoolsEntryKind = 'query' | 'query-stack' | 'paged-query-stack' | 'query-sequence' | 'query-batch' | 'auth-provider' | 'ws-client' | 'query-form';
 /**
  * One chunk of a parsed query route: either literal text (`param: null`) or a path param, whose name
  * is in {@link QueryDevtoolsRoutePart.text}. Lets the devtools tell a route's static parts from its
@@ -4844,6 +5155,18 @@ type QueryDevtoolsEntryMeta = {
     authProviderName?: string;
     /** The provider's own queries, for auth providers. */
     authQueries?: QueryDevtoolsAuthQuery[];
+    /**
+     * The batch that created a query, for the one query `createQueryBatch` runs per item. The panel folds
+     * such queries under their batch's own entry instead of listing a row per item, and the registry caps
+     * their tombstones per batch so a bulk run cannot evict everything else it kept.
+     */
+    batch?: QueryBatchDevtoolsHandle;
+    /** Which of the batch's items the query was created for, for a batch's item query. */
+    batchItemIndex?: number;
+    /** How many of a batch's requests may be in flight at once, for batches. */
+    concurrency?: number;
+    /** Whether a batch's first failure stops the rest of the run, for batches. */
+    stopOnError?: boolean;
     /** The query config passed at creation, for queries. */
     queryConfig?: QueryConfig;
     /** The creator options passed at creation, for queries. */
@@ -5401,6 +5724,12 @@ declare const applyQueryDevtoolsTokenTtl: <T>(options: {
  * so the list is capped for the same reason the repository caps its unused entries.
  */
 declare const MAX_QUERY_DEVTOOLS_TOMBSTONES = 50;
+/**
+ * How many of its settled items' queries one batch keeps. Counted per batch rather than against
+ * {@link MAX_QUERY_DEVTOOLS_TOMBSTONES}, so a bulk run cannot evict the tombstones the panel is read
+ * for - and low, because the batch's own entry already holds every item's args, response and error.
+ */
+declare const MAX_QUERY_BATCH_TOMBSTONES = 20;
 /**
  * A destroyed query's last state, shaped like the query itself: every signal the panel reads is
  * replaced by a function returning the value it held when the query went away, and every action is a
@@ -7594,7 +7923,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "text" | "json" | "blob" | "arraybuffer" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -7604,7 +7933,7 @@ declare class QueryDevtoolsComponent {
         secure: boolean | undefined;
         route: any;
         reportProgress: boolean | undefined;
-        responseType: "json" | "text" | "blob" | "arraybuffer" | undefined;
+        responseType: "text" | "json" | "blob" | "arraybuffer" | undefined;
         withCredentials: boolean | undefined;
         autoRefreshOn: _ethlete_query.QueryAutoRefreshConfig | undefined;
         enableSmartPolling: boolean | undefined;
@@ -8492,7 +8821,7 @@ type AnyWebSocketClient<TMessageData extends SocketMessageView = SocketMessageVi
 declare const createWebSocketClient: <TMessageData extends SocketMessageView = SocketMessageView>(options: CreateWebSocketClientConfigOptions) => WebSocketClientResult<TMessageData>;
 
 /** The version of `@ethlete/query` this build was cut from. */
-declare const QUERY_VERSION = "6.0.0-next.37";
+declare const QUERY_VERSION = "6.0.0-next.39";
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, 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_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, 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, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, 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, createQueryDevtoolsOverrides, 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, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, 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, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
-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, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, AuthGuardTarget, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthActivityCoordination, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, 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, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsAppInfo, QueryDevtoolsAuthQuery, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, 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, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, 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_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, 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, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsOverrides, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, 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, deleteQueryDevtoolsMock, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsFaultArmed, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, restoredQueryDevtoolsOverrides, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope, setQueryDevtoolsSettings, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, 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, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export type { AnyBearerAuthProvider, AnyCreateBearerAuthProviderResult, AnyCreateGqlQueryCreatorOptions, AnyCreateQueryClientResult, AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryBatch, AnyQueryBatchItemResult, AnyQueryBuilder, AnyQueryClient, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyQuerySnapshot, AnyQueryStack, AnyRestQueryConfig, AnyRoute, AnyV2Query, AnyV2QueryCreator, AnyWebSocketClient, AppendItemsLocation, ApplyExternalResponseOptions, ApplyPersistedResponseOptions, AuthGuard, AuthGuardConfig, AuthGuardTarget, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, AuthQueryBuilder, AuthQueryConfig, BaseArguments, BaseQueryCreatorFactoryOptions, BaseQueryCreatorOptions, BaseQueryCreatorOptionsSubtle, BearerAuthActivityCoordination, BearerAuthExecutionState, BearerAuthExecutionStateError, BearerAuthExecutionStateLoading, BearerAuthExecutionStateLogout, BearerAuthExecutionStateSuccess, BearerAuthExecutionStateTokenSeed, BearerAuthFeature, BearerAuthMultiTabSyncConfig, BearerAuthMultiTabSyncFeature, BearerAuthProvider, BearerAuthProviderEarlySetup, BearerAuthProviderEarlySetupContext, BearerAuthProviderEarlySetupResult, BearerAuthProviderFeatureContext, BearerAuthProviderOf, BearerAuthProviderQueryContext, BearerAuthProviderRef, BearerAuthProviderTokens, BearerAuthRefreshCoordination, BearerAuthSessionEndCause, BearerAuthSessionStatus, BearerRefreshConfig, BodyType, BuildQueryStringConfig, CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, CreateBaseQueryOptions, CreateBearerAuthProviderConfig, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateIndexedDbQueryPersistenceAdapterOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryBatchOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryPersistenceEngineOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateQuerySubmissionConfig, CreateQuerySyncEngineOptions, CreateSecureGqlQueryExecuteOptions, CreateSecureGqlQueryOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfigOptions, CreateWebSocketClientTransport, DefaultRetryOptions, DefineQueryFormConfig, DescribableFeature, 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, HttpRequestRetryState, HttpRequestSubtle, HttpRequestTransferCacheConfig, InactivityLogoutConfig, InactivityLogoutFeature, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalSecureCreateGqlQueryCreatorOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, JsonPath, LeaderInstanceCountChangeEventData, LeaderStatusChangeEventData, LegacyArgumentsOfQueryArgs, LegacyQueryPrepareFn, Loading, LogoutEventData, MapViolationsToFormErrorsOptions, Method, ObservableSignal, OptionalQueryFieldOptions, OverrideOp, PageParamCalculatorOptions, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, PartialXhrState, PathParams, PathParamsType, PersistedQueryBody, PersistedQueryEntry, PersistedQueryEntryMeta, PersistentAuthConfig, PersistentAuthFeature, PollConfig, Prepared, Query, QueryArgs, QueryArgsOf, QueryArgsOfLegacyArguments, QueryAutoRefreshConfig, QueryBase, QueryBatch, QueryBatchDevtoolsHandle, QueryBatchItemCancelled, QueryBatchItemError, QueryBatchItemResult, QueryBatchItemSkipped, QueryBatchItemSuccess, QueryBatchResult, QueryBatchStatus, QueryClient, QueryClientDevtoolsOptions, QueryClientErrorPipelineFeature, QueryClientFeature, QueryClientFeatureContext, QueryClientFeatureFn, QueryClientMultiTabSyncFeature, QueryClientPersistenceFeature, QueryClientRef, QueryClientSubtle, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryContext, QueryCreator, QueryDataOf, QueryDependencies, QueryDevtoolsAbout, QueryDevtoolsAppInfo, QueryDevtoolsAuthQuery, QueryDevtoolsEntry, QueryDevtoolsEntryKind, QueryDevtoolsEntryMeta, QueryDevtoolsFault, QueryDevtoolsFaultTarget, QueryDevtoolsFeature, QueryDevtoolsFeatureDescriber, QueryDevtoolsFeatureDetail, QueryDevtoolsFormField, QueryDevtoolsFormHandle, QueryDevtoolsFormLinksHandle, QueryDevtoolsFormLinksRecorder, QueryDevtoolsMock, QueryDevtoolsMockTarget, QueryDevtoolsOptions, QueryDevtoolsOverrideEntry, QueryDevtoolsOverrideTransfer, QueryDevtoolsOverrideTransferParse, QueryDevtoolsOverridesHandle, QueryDevtoolsOverridesRecorder, QueryDevtoolsPayload, QueryDevtoolsRegistrar, QueryDevtoolsRegistration, QueryDevtoolsResolvedFault, QueryDevtoolsResolvedMock, QueryDevtoolsRoutePart, QueryDevtoolsRun, QueryDevtoolsRunError, QueryDevtoolsRunStatus, QueryDevtoolsSchemaComponents, QueryDevtoolsSchemaLoader, QueryDevtoolsSchemaLoaders, QueryDevtoolsSchemaRoute, QueryDevtoolsSchemaSeed, QueryDevtoolsSchemaState, QueryDevtoolsSeedStyle, QueryDevtoolsSettings, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsStatsRecorder, QueryDevtoolsStorageScope, QueryDirectiveContext, QueryDirectiveType, QueryEntityConfig, QueryErrorParser, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteEventData, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateFailureWithCachedResponse, QueryExecutionStateFailureWithNoResponse, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFailureEventData, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFieldConfig, QueryFieldDef, QueryFieldOptions, QueryFieldValue, QueryFilterConfig, QueryFormBranch, QueryFormChange, QueryFormFields, QueryFormGroup, QueryFormGroupControls, QueryFormModel, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormSignals, QueryFormSignalsObserveOptions, QueryFormSignalsWriteOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryInvalidationCandidate, QueryInvalidationFilterFn, QueryInvalidationOptions, QueryKey, QueryKeyLockHold, QueryKeyLockHoldOptions, QueryKeyLockManager, QueryKeyLockState, QueryMethod, QueryMockConfig, QueryMultiTabSyncConfig, QueryOf, QueryParams, QueryParamsType, QueryPersistenceAdapter, QueryPersistenceCandidate, QueryPersistenceConfig, QueryPersistenceEngine, QueryPrepareFn, QueryRefreshCause, QueryRegistry, QueryRegistryEntry, QueryRepository, QueryRepositoryCacheEntry, QueryRepositoryDependencies, QueryRepositoryEntryDestroyedCause, QueryRepositoryEvent, QueryRepositoryItem, QueryRepositoryRefreshFilterFn, QueryRepositoryRequestOptions, QueryRepositorySubtle, QueryResponseOf, QueryRouteOf, QuerySequence, QuerySequenceResult, QuerySequenceStatus, QuerySequenceStepArgs, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSubtle, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QuerySubmissionRef, QuerySubtle, QuerySuccessEventData, QuerySyncEngine, QuerySyncEnvelope, QuerySyncInvalidateMessage, QuerySyncMessage, QuerySyncMessageListener, QuerySyncMutation, QuerySyncMutationFilterFn, QuerySyncMutationMessage, QuerySyncRefreshCandidate, QuerySyncRefreshOnMutationConfig, QuerySyncResponseMessage, QuerySyncTransport, QueryTrigger, RawResponseType, ReadonlyQuery, RefreshFailure, RemoveFromConfig, RequestArgs, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestHttpEvent, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, RequiresTransform, ResetExecuteStateOptions, ResetPageOnErrorOperatorConfig, ResponseType, RestQueryConfig, RestoredQueryDevtoolsOverrides, 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, WebSocketClientIo, WebSocketClientIoOptions, WebSocketClientResult, WebSocketClientSocket, WebSocketClientSubtle, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, WebSocketRoom, WithAutoRefreshFeatureOptions, WithBody, WithConfig, WithErrorHandlingFeatureOptions, WithHeaders, WithInjector, WithLegacyConfig, WithLoggingFeatureOptions, WithLongPollingFeatureOptions, WithMock, WithPageResetOnErrorFeatureOptions, WithPathParams, WithPollingFeatureOptions, WithQueryParams, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, WithVariables };