@ethlete/query 5.40.0 → 5.41.0

package/index.d.ts

@@ -1,20 +1,3600 @@
-export * from './lib/auth';
-export * from './lib/class-validator';
-export * from './lib/devtools/components/query-devtools';
-export * from './lib/devtools/pipes';
-export * from './lib/devtools/utils';
-export * from './lib/directives';
-export * from './lib/entity';
-export * as ExperimentalQuery from './lib/experimental';
-export * from './lib/experimental/pipes';
-export * from './lib/gql';
-export * from './lib/infinite-query';
-export * from './lib/logger';
-export * from './lib/query';
-export * from './lib/query-client';
-export * from './lib/query-creator';
-export * from './lib/query-form';
-export * from './lib/query-store';
-export * from './lib/request';
-export * from './lib/symfony';
-export * from './lib/utils';
+import * as rxjs from 'rxjs';
+import { Observable, Subscribable, BehaviorSubject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { DestroyRef, EnvironmentInjector, ɵEffectScheduler as _EffectScheduler, ErrorHandler, Signal, CreateEffectOptions, WritableSignal, EffectRef, InjectionToken, Injector, CreateComputedOptions, PipeTransform, TrackByFunction, OnInit, OnDestroy } from '@angular/core';
+import { HttpStatusCode, HttpErrorResponse, HttpClient, HttpEvent, HttpHeaders, HttpContext } from '@angular/common/http';
+import * as _angular_forms from '@angular/forms';
+import { FormControl, FormGroup } from '@angular/forms';
+import * as _ethlete_query from '@ethlete/query';
+import { ToSignalOptions, ToObservableOptions } from '@angular/core/rxjs-interop';
+import * as i1 from '@ethlete/core';
+import { RuntimeError } from '@ethlete/core';
+import { Paginated, NormalizedPagination, GgLikePaginated, DynLikePaginated, ContentfulGqlLikePaginated, FormViolationListView, FormViolationView } from '@ethlete/types';
+import * as _angular_common_module_d_yNBsZ8gb from '@angular/common/module.d-yNBsZ8gb';
+
+type EntityKey = string | number;
+interface EntityStoreConfig {
+    name: string;
+    logActions?: boolean;
+}
+interface InsertFromConfig<OriginStoreType, OriginKeys extends keyof NonNullable<OriginStoreType>, IdFn extends (value: NonNullable<OriginStoreType>) => EntityKey | EntityKey[]> {
+    /**
+     * The property key of which the value should be replaced.
+     */
+    for: OriginKeys;
+    /**
+     * A function that returns the id of the entity. Can also return an array of ids.
+     */
+    id: IdFn;
+}
+interface RemoveFromConfig<T> {
+    /**
+     * The where function to select the entities to remove.
+     */
+    where: (entity: T) => boolean;
+    /**
+     * A function that returns the id of the entity.
+     */
+    id: (entity: T) => EntityKey;
+}
+
+declare class EntityStore<T> {
+    private readonly _config;
+    constructor(_config: EntityStoreConfig);
+    select(key: EntityKey): Observable<T | null>;
+    select(keys: EntityKey[]): Observable<T[]>;
+    select(keys: EntityKey[][]): Observable<T[]>;
+    /**
+     * **Note:** Prefer `select` over `selectWhere` when possible.
+     */
+    selectWhere(predicate: (value: T) => boolean): Observable<T[]>;
+    set(key: EntityKey, value: T): void;
+    set(keys: EntityKey[], values: T[]): void;
+    set(keys: EntityKey[][], values: T[][]): void;
+    remove(key: EntityKey): void;
+    remove(keys: EntityKey[]): void;
+    remove(keys: EntityKey[][]): void;
+    logState(): void;
+    private _select;
+    private _selectMany;
+    private _set;
+    private _remove;
+    private _normalizeKeys;
+}
+
+declare function mapToPaginated<T>(response: Paginated<T>): rxjs.OperatorFunction<unknown, Paginated<T>>;
+/**
+ * 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>;
+/**
+ * Remove entities from a store based on a where function.
+ */
+declare const removeFrom: <T>(store: EntityStore<T>, { where, id }: RemoveFromConfig<T>) => void;
+
+type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+interface RequestError<Detail = unknown> {
+    url: string;
+    status: HttpStatusCode;
+    statusText: string;
+    detail: Detail;
+    httpErrorResponse: HttpErrorResponse;
+}
+type RequestHeaders = Record<string, string>;
+type QueryParams = object;
+type PathParams = Record<string, string | number>;
+type CacheAdapterFn$1 = (headers: RequestHeaders) => number | null;
+type RequestHeadersMethodMap = {
+    [M in Method]?: RequestHeaders;
+};
+interface PartialXhrState {
+    headers: RequestHeaders;
+    status: number;
+    statusText: string;
+    url: string;
+}
+interface RequestRetryFnConfig {
+    error: RequestError;
+    headers: RequestHeaders;
+    currentRetryCount: number;
+}
+interface RequestRetryFnResult {
+    retry: boolean;
+    delay?: number;
+}
+type RequestRetryFn = (config: RequestRetryFnConfig) => RequestRetryFnResult;
+interface RequestConfig {
+    method: Method;
+    urlWithParams: string;
+    body?: unknown;
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    headers?: RequestHeaders;
+    cacheAdapter?: CacheAdapterFn$1;
+    retryFn?: RequestRetryFn;
+}
+type RequestProgress = {
+    current: number;
+    percentage?: number;
+    total?: number;
+};
+type RequestEvent<Response = unknown> = {
+    type: 'start';
+    headers: RequestHeaders;
+    isRetry?: boolean;
+    retryNumber?: number;
+    retryDelay?: number;
+} | {
+    type: 'delay-retry';
+    headers: RequestHeaders;
+    retryNumber: number;
+    retryDelay: number;
+} | {
+    type: 'download-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+    partialText?: string;
+} | {
+    type: 'upload-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+} | {
+    type: 'success';
+    headers: RequestHeaders;
+    response: Response;
+    expiresInTimestamp?: number;
+} | {
+    type: 'failure';
+    headers: RequestHeaders;
+    error: RequestError;
+} | {
+    type: 'cancel';
+    headers: RequestHeaders;
+};
+interface BuildQueryStringConfig {
+    /**
+     * Object notation to use for nested objects.
+     *
+     * @example
+     * // dot notation
+     * { foo: { bar: 'baz' } } => "foo.bar=baz"
+     *
+     * @example
+     * // bracket notation
+     * { foo: { bar: 'baz' } } => "foo[bar]=baz"
+     *
+     * @example
+     * // json-stringify notation
+     * { foo: { bar: 'baz' } } => "foo={\"bar\":\"baz\"}"
+     *
+     * @default 'bracket'
+     */
+    objectNotation?: 'dot' | 'bracket' | 'json-stringify';
+    /**
+     * Whether to write array indexes in bracket notation.
+     *
+     * @example
+     * // true
+     * { foo: ['bar', 'baz'] } => "foo[0]=bar&foo[1]=baz"
+     *
+     * @example
+     * // false
+     * { foo: ['bar', 'baz'] } => "foo[]=bar&foo[]=baz"
+     *
+     * @default false
+     */
+    writeArrayIndexes?: boolean;
+    /**
+     * A list of values that should be ignored when building the query string.
+     *
+     * Also have a look at `ignoredValuesFns`.
+     *
+     * @default [undefined, null, Infinity, -Infinity]
+     */
+    ignoredValues?: Array<unknown>;
+    /**
+     * A list of functions that should be used to determine whether a value should be ignored when building the query string.
+     *
+     * Also have a look at `ignoredValues`.
+     *
+     * @default [isNaN, isEmptyString]
+     */
+    ignoredValuesFns?: Array<(value: unknown) => boolean>;
+}
+
+declare const request: <Response = unknown>(config: RequestConfig) => Observable<RequestEvent<Response>>;
+
+declare const isNaN: (value: unknown) => boolean;
+declare const isEmptyString: (value: unknown) => boolean;
+declare const isRequestError: <T = unknown>(error: unknown) => error is RequestError<T>;
+declare const buildRoute: (options: {
+    base: string;
+    route: AnyRoute | null | undefined;
+    pathParams?: PathParams;
+    queryParams?: QueryParams;
+    queryParamConfig?: BuildQueryStringConfig;
+}) => string;
+declare const buildQueryString: (params: QueryParams, config?: BuildQueryStringConfig) => string | null;
+declare const extractExpiresInSeconds$1: (headers: RequestHeaders) => number | null;
+declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
+declare const serializeBody: (body: unknown) => ArrayBuffer | URLSearchParams | Blob | FormData | string | null;
+declare const transformMethod: (config: {
+    method: Method;
+    transferVia?: "GET" | "POST";
+}) => "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;
+declare const parseAllXhrResponseHeaders: (xhr: XMLHttpRequest) => RequestHeaders;
+declare const getResponseUrl: (xhr: XMLHttpRequest) => string | null;
+declare const shouldRetryRequest$1: RequestRetryFn;
+
+type SetupQueryDependenciesOptions = {
+    clientConfig: QueryClientConfig$1;
+    queryConfig: QueryConfig$1 | undefined;
+};
+type QueryDependencies = {
+    /** The destroy ref of the query. */
+    destroyRef: DestroyRef;
+    /** The destroy ref of the scope the query is in (e.g. a component) */
+    scopeDestroyRef: DestroyRef;
+    /** The query client */
+    client: QueryClient$1;
+    /** The injector of the query */
+    injector: EnvironmentInjector;
+    /** The effect scheduler */
+    effectScheduler: _EffectScheduler;
+    /** The error handler */
+    ngErrorHandler: ErrorHandler;
+    /** The http client */
+    httpClient: HttpClient;
+};
+declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;
+
+type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions, 'route'> & {
+    route?: RouteType$1<TArgs>;
+};
+type GqlQueryMethod = 'QUERY' | 'MUTATE';
+type GqlQueryTransport = 'GET' | 'POST';
+type InternalCreateGqlQueryCreatorOptions = {
+    method: GqlQueryMethod;
+    transport: GqlQueryTransport;
+    client: QueryClientConfig$1;
+    query: string;
+};
+declare const createGqlQueryCreator: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryCreatorOptions<TArgs> | undefined, internals: InternalCreateGqlQueryCreatorOptions) => QueryCreator$1<TArgs>;
+
+type GqlQueryArgs = QueryArgs & {
+    variables?: Record<string, unknown>;
+};
+type CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creator' | 'creatorInternals'> & {
+    creator?: CreateGqlQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateGqlQueryCreatorOptions;
+};
+type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ? T['variables'] : never;
+declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<TArgs>) => options is CreateGqlQueryOptions<TArgs>;
+declare const createGqlQuery: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryOptions<TArgs>) => Query$1<TArgs>;
+
+declare const enum QueryFeatureType {
+    WithArgs = "withArgs",
+    WithLogging = "withLogging",
+    WithErrorHandling = "withErrorHandling",
+    WithSuccessHandling = "withSuccessHandling",
+    WithPolling = "withPolling",
+    WithAutoRefresh = "withAutoRefresh",
+    WithResponseUpdate = "withResponseUpdate"
+}
+type QueryFeatureContext<TArgs extends QueryArgs> = {
+    state: QueryState$1<TArgs>;
+    execute: InternalQueryExecute<TArgs>;
+    deps: QueryDependencies;
+    flags: QueryFeatureFlags;
+};
+type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;
+type QueryFeature<TArgs extends QueryArgs> = {
+    type: QueryFeatureType;
+    fn: (context: QueryFeatureContext<TArgs>) => void;
+};
+/**
+ * A query feature that allows you to set the arguments of the query.
+ * The arguments are read within a computed function, so you can use reactive values.
+ *
+ * To set the arguments to `null`, return the symbol `CLEAR_QUERY_ARGS`.
+ * If you instead return `null`, the arguments won't change.
+ *
+ * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
+ */
+declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | ClearQueryArgs | null) => QueryFeature<TArgs>;
+type WithPollingFeatureOptions = {
+    /** The interval in milliseconds at which the query should be executed */
+    interval: number;
+    /**
+     * Whether the query should be executed initially.
+     * By default, the query will be executed after the first interval.
+     * @default false
+     */
+    executeInitially?: boolean;
+};
+/**
+ * A query feature that will automatically execute the query at a given interval.
+ * The interval will be cleared when the query is destroyed.
+ * The interval will be reset when the arguments of the query change.
+ *
+ * @throws If the query is not eligible for auto execution (e.g. a POST request)
+ */
+declare const withPolling: <TArgs extends QueryArgs>(options: WithPollingFeatureOptions) => QueryFeature<TArgs>;
+type WithLoggingFeatureOptions<TArgs extends QueryArgs> = {
+    /** A function that will be called with the latest http event */
+    logFn: (v: HttpEvent<ResponseType<TArgs>> | null) => void;
+};
+/** A query feature that can be used to log the latest http event */
+declare const withLogging: <TArgs extends QueryArgs>(options: WithLoggingFeatureOptions<TArgs>) => QueryFeature<TArgs>;
+type WithErrorHandlingFeatureOptions = {
+    /** A function that will be called with the latest error */
+    handler: (e: QueryErrorResponse) => void;
+};
+/** A query feature that can be used to handle errors */
+declare const withErrorHandling: <TArgs extends QueryArgs>(options: WithErrorHandlingFeatureOptions) => QueryFeature<TArgs>;
+type WithSuccessHandlingFeatureOptions<TArgs extends QueryArgs> = {
+    /** A function that will be called with the latest response */
+    handler: (data: NonNullable<ResponseType<TArgs>>) => void;
+};
+/** A query feature that can be used to handle successful responses */
+declare const withSuccessHandling: <TArgs extends QueryArgs>(options: WithSuccessHandlingFeatureOptions<TArgs>) => QueryFeature<TArgs>;
+type WithAutoRefreshFeatureOptions = {
+    /** The signals that should trigger a refresh of the query */
+    onSignalChanges: Signal<unknown>[];
+    /** Whether to ignore the `onlyManualExecution` query config flag */
+    ignoreOnlyManualExecution?: boolean;
+};
+/**
+ * A query feature that will automatically execute the query when any of the provided signals change
+ * @throws If the query is not eligible for auto execution (e.g. a POST request)
+ * @throws If the query has the `onlyManualExecution` query config flag set and `ignoreOnlyManualExecution` is not set
+ */
+declare const withAutoRefresh: <TArgs extends QueryArgs>(options: WithAutoRefreshFeatureOptions) => QueryFeature<TArgs>;
+type WithResponseUpdateFeatureFnData<TArgs extends QueryArgs> = {
+    /** The current response of the query */
+    currentResponse: ResponseType<TArgs> | null;
+};
+type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
+    /**
+     * A function that will be called with the latest response
+     * If the function returns `null`, the response will not be updated.
+     * Otherwise, the response will be updated with the returned value.
+     * The function will be called in a reactive signal context.
+     * If the query get's executed after the response was updated, the response will be set the the fresh data received from the server.
+     *
+     * This feature is most useful in combination with web sockets where the data received from the socket might be more up-to-date than the data received previously.
+     *
+     * @example
+     * const matchEvents = mySocket.joinRoom('match-events');
+     *
+     * const myMatchQuery = getMatch(
+     *  withArgs(() => ({ matchId: 1 })),
+     *  withResponseUpdate(({ currentResponse }) => {
+     *   const matchEvent = matchEvents();
+     *
+     *   if (!matchEvent) return null;
+     *
+     *   // Do some checks here. This is just a very simple example.
+     *   // To apply partial updates, you can use the spread operator in combination with the current response.
+     *
+     *   return matchEvent;
+     *  })
+     * )
+     */
+    updater: (data: WithResponseUpdateFeatureFnData<TArgs>) => ResponseType<TArgs> | null;
+};
+declare const withResponseUpdate: <TArgs extends QueryArgs>(options: WithResponseUpdateFeatureOptions<TArgs>) => QueryFeature<TArgs>;
+
+/**
+ * Returning this inside a withArgs feature will reset the query args to null.
+ * This will also pause polling and auto refresh until new args are set.
+ */
+declare const CLEAR_QUERY_ARGS: unique symbol;
+type ClearQueryArgs = typeof CLEAR_QUERY_ARGS;
+/** A angular effect that can be nested inside another effect */
+declare const nestedEffect: (fn: () => void, options?: CreateEffectOptions) => _angular_core.EffectRef;
+declare const circularQueryDependencyChecker: () => {
+    check: () => void;
+};
+declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
+declare const shouldAutoExecuteGqlQuery: (method: GqlQueryMethod) => method is "QUERY";
+declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
+type ShouldRetryRequestOptions = {
+    retryCount: number;
+    error: HttpErrorResponse;
+};
+type ShouldRetryRequestResult = {
+    retry: false;
+} | {
+    retry: true;
+    delay: number;
+};
+type ShouldRetryRequestFn = (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
+declare const shouldRetryRequest: (options: ShouldRetryRequestOptions | HttpErrorResponse) => ShouldRetryRequestResult;
+type QueryFeatureFlags = {
+    hasWithArgsFeature: boolean;
+    shouldAutoExecuteMethod: boolean;
+    shouldAutoExecute: boolean;
+    hasRouteFunction: boolean;
+    onlyManualExecution?: boolean;
+    /** Human readable method name */
+    method: string;
+};
+declare const getQueryFeatureUsage: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<TArgs>) => QueryFeatureFlags;
+declare const applyQueryFeatures: <TArgs extends QueryArgs>(features: QueryFeature<TArgs>[], context: QueryFeatureContext<TArgs>) => void;
+declare const maybeExecute: (options: {
+    flags: QueryFeatureFlags;
+    execute: InternalQueryExecute<any>;
+}) => void;
+type CreateQueryObjectOptions<TArgs extends QueryArgs> = {
+    state: QueryState$1<TArgs>;
+    deps: QueryDependencies;
+    execute: InternalQueryExecute<TArgs>;
+};
+declare const createQueryObject: <TArgs extends QueryArgs>(options: CreateQueryObjectOptions<TArgs>) => Query$1<TArgs>;
+declare const normalizeQueryRepositoryKey: (key: Signal<QueryKeyOrNone>) => Signal<string>;
+declare const shouldCacheQuery$1: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
+declare const buildQueryCacheKey$1: (route: string, args: RequestArgs<QueryArgs> | undefined) => string;
+
+type QueryErrorResponseList = {
+    isList: true;
+    errors: QueryErrorResponseItem[];
+};
+type QueryErrorResponseSingle = {
+    isList: false;
+    error: QueryErrorResponseItem;
+};
+type QueryErrorResponse = {
+    raw: HttpErrorResponse;
+    retryState: ShouldRetryRequestResult;
+    code: HttpStatusCode;
+} & (QueryErrorResponseList | QueryErrorResponseSingle);
+type QueryErrorResponseItem = {
+    message: string;
+};
+declare const createQueryErrorResponse: (error: unknown) => QueryErrorResponse;
+
+type SetupQueryStateOptions = {};
+type QueryStateSubtle<TArgs extends QueryArgs> = {
+    request: WritableSignal<HttpRequest<TArgs> | null>;
+};
+type QueryState$1<TArgs extends QueryArgs> = {
+    response: WritableSignal<ResponseType<TArgs> | null>;
+    args: WritableSignal<RequestArgs<TArgs> | null>;
+    latestHttpEvent: WritableSignal<HttpEvent<ResponseType<TArgs>> | null>;
+    loading: WritableSignal<HttpRequestLoadingState | null>;
+    error: WritableSignal<QueryErrorResponse | null>;
+    lastTimeExecutedAt: WritableSignal<number | null>;
+    executionState: Signal<QueryExecutionState<TArgs> | null>;
+    subtle: QueryStateSubtle<TArgs>;
+};
+type QueryExecutionStateSuccess<TArgs extends QueryArgs> = {
+    type: 'success';
+    response: ResponseType<TArgs>;
+};
+type QueryExecutionStateFailure = {
+    type: 'failure';
+    error: QueryErrorResponse;
+};
+type QueryExecutionStateLoadingWithNoResponse = {
+    type: 'loading';
+    hasCachedResponse: false;
+    loading: HttpRequestLoadingState;
+};
+type QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = {
+    type: 'loading';
+    hasCachedResponse: true;
+    loading: HttpRequestLoadingState;
+    cachedResponse: ResponseType<TArgs>;
+};
+type QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithNoResponse | QueryExecutionStateLoadingWithCachedResponse<TArgs>;
+type QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs> | QueryExecutionStateFailure | QueryExecutionStateLoading<TArgs>;
+declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions) => QueryState$1<TArgs>;
+
+type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
+    deps: QueryDependencies;
+    state: QueryState$1<TArgs>;
+    creator?: CreateQueryCreatorOptions;
+    creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
+    queryConfig: QueryConfig$1;
+};
+type QueryExecuteArgs<TArgs extends QueryArgs> = {
+    args?: RequestArgs<TArgs> | null;
+    options?: RunQueryExecuteOptions;
+};
+type InternalQueryExecute<TArgs extends QueryArgs> = {
+    (executeArgs?: QueryExecuteArgs<TArgs>): void;
+    reset: () => void;
+    currentRepositoryKey: Signal<QueryKeyOrNone>;
+};
+type QueryExecute<TArgs extends QueryArgs> = (executeArgs?: QueryExecuteArgs<TArgs>) => void;
+declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;
+
+type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
+    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state' | 'deps'>;
+    executeState: QueryExecuteState;
+};
+declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
+type QueryExecuteState = {
+    effectRefs: EffectRef[];
+    previousKey: WritableSignal<string | false>;
+};
+declare const setupQueryExecuteState: () => QueryExecuteState;
+type RunQueryExecuteOptions = {
+    allowCache?: boolean;
+};
+type InternalRunQueryExecuteOptions = {
+    /**
+     * If true, the request will be forced to be cached (saved inside the query repository).
+     * Can be used to e.g. cache GQL queries transported via POST
+     *
+     * - `true` means the request will always be cached
+     * - `false` means the request will never be cached
+     * - `undefined` means the request will be cached if the method is GET, OPTIONS or HEAD
+     */
+    useQueryRepositoryCache?: boolean;
+};
+type QueryExecuteOptions<TArgs extends QueryArgs> = {
+    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeState: QueryExecuteState;
+    args: RequestArgs<TArgs> | null;
+    options?: RunQueryExecuteOptions;
+    internalOptions?: InternalRunQueryExecuteOptions;
+    transformResponse?: (response: any) => any;
+    isSecure?: boolean;
+};
+declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+type CleanupPreviousExecuteOptions<TArgs extends QueryArgs> = {
+    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state'>;
+    executeState: QueryExecuteState;
+};
+declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: CleanupPreviousExecuteOptions<TArgs>) => void;
+
+type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
+    /**
+     * The route of the request.
+     * @example '/users'
+     * @example (args) => `/users/${args.userId}`
+     */
+    route: RouteType$1<TArgs>;
+    /** The HTTP method of the request */
+    method: QueryMethod;
+    /** If the request is secure (needs authentication) */
+    isSecure?: boolean;
+    /** The data of the request */
+    args?: RequestArgs<TArgs> | null;
+    /** The client options of the request */
+    clientOptions?: CreateHttpRequestClientOptions;
+    /** If set, this request's cache key will be prefixed with this key */
+    key?: string;
+    /** The previous cache key of the request */
+    previousKey?: string | false;
+    /** The destroy ref to bind the request to. If the destroy ref is destroyed, the request will be destroyed as well. */
+    consumerDestroyRef: DestroyRef;
+    /** Configuration on how to run the query */
+    runQueryOptions?: RunQueryExecuteOptions;
+    /** Internal options for running the query */
+    internalRunQueryOptions?: InternalRunQueryExecuteOptions;
+};
+type QueryRepositoryItem<TArgs extends QueryArgs> = {
+    /** The key of the request. If the key is `false`, the request is not cached, otherwise it is. */
+    key: QueryKeyOrNone;
+    /** The request object */
+    request: HttpRequest<TArgs>;
+};
+/**
+ * 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.
+ * It will also destroy requests if there are no more consumers left.
+ */
+type QueryRepository = {
+    /** Creates a new request. If the request is already cached, it will be reused. */
+    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => QueryRepositoryItem<TArgs>;
+    /** Removes a consumer from a request by its key. Destroys the request if there are no more consumers left. */
+    unbind: (key: QueryKeyOrNone, consumerDestroyRef: DestroyRef) => boolean;
+    /** Removes all secure requests and their consumers */
+    unbindAllSecure: () => void;
+};
+/** The key of a query */
+type QueryKey = string;
+/** A key that will not be cached */
+type QueryKeyNoCache = false;
+/** A key that may or may not be cached */
+type QueryKeyOrNone = QueryKey | QueryKeyNoCache;
+type QueryRepositoryDependencies = {
+    /** The HTTP client to use for the requests */
+    httpClient: HttpClient;
+    /** The error handler to use for the requests */
+    ngErrorHandler: ErrorHandler;
+};
+type CreateQueryRepositoryConfig = QueryClientConfig$1 & {
+    /** The dependencies of the query repository */
+    dependencies: QueryRepositoryDependencies;
+};
+declare const createQueryRepository: (config: CreateQueryRepositoryConfig) => QueryRepository;
+
+type QueryClient$1 = {
+    repository: QueryRepository;
+};
+declare const createQueryClient: (config: QueryClientConfig$1) => QueryClient$1;
+declare const provideQueryClient: (config: QueryClientConfig$1) => {
+    provide: QueryClientRef;
+    useFactory: () => QueryClient$1;
+};
+
+type CacheAdapterFn = (headers: HttpHeaders) => number | null;
+type CreateQueryClientConfigOptions = {
+    /**
+     * The base URL of the client
+     * @example 'https://api.example.com/v1'
+     */
+    baseUrl: string;
+    /** Configuration for building query strings */
+    queryString?: BuildQueryStringConfig;
+    /** The name of the client */
+    name: string;
+    /**
+     * The cache adapter function to use for the client.
+     * It determines how long the response of a request can be cached.
+     *
+     * @default extractExpiresInSeconds()
+     */
+    cacheAdapter?: CacheAdapterFn;
+    /**
+     * The retry function to use for the client.
+     * It determines if a request should be retried after it failed.
+     *
+     * @default shouldRetryRequest()
+     */
+    retryFn?: ShouldRetryRequestFn;
+};
+type QueryClientConfig$1 = CreateQueryClientConfigOptions & {
+    /** A generated token for dependency injection */
+    token: QueryClientRef;
+};
+/**
+ * A token for a query client.
+ * This token can be used to inject a query client into a service.
+ */
+type QueryClientRef = InjectionToken<QueryClient$1>;
+/**
+ * This function creates a query client config.
+ * The config is used to create a query client using the `provideQueryClient(myConfig)` function.
+ */
+declare const createQueryClientConfig: (options: CreateQueryClientConfigOptions) => QueryClientConfig$1;
+
+type RouteType$1<TArgs extends QueryArgs> = PathParamsType<TArgs> extends {
+    [key: string]: unknown;
+} ? (args: TArgs['pathParams']) => RouteString$1 : RouteString$1;
+type RouteString$1 = `/${string}`;
+type CreateQueryCreatorOptions = {
+    /**
+     * If true, the query loading state will include progress information.
+     * This is useful for file uploads and downloads.
+     *
+     * **Warning**: Upload progress events are not supported by browsers when using the fetch API, such as with `provideHttpClient(withFetch())`.
+     * In this case, you should use the older XHR implementation by omitting `withFetch()`. But take into account that XHR is not supported in server-side rendering environments.
+     *
+     * @see https://angular.dev/guide/http/making-requests#receiving-raw-progress-events
+     *
+     * @default false
+     */
+    reportProgress?: boolean;
+    /**
+     * The response type of the query.
+     * @default 'json'
+     */
+    responseType?: HttpRequestResponseType;
+    /**
+     * Whether to include credentials (cookies) in the request or not.
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * This property accepts either a boolean to enable/disable transferring cache for eligible
+     * requests performed using `HttpClient`, or an object, which allows to configure cache
+     * parameters, such as which headers should be included (no headers are included by default).
+     *
+     * Setting this property will override the options passed to `provideClientHydration()` for this
+     * particular request
+     */
+    transferCache?: HttpRequestTransferCacheConfig;
+};
+type QueryCreator$1<TArgs extends QueryArgs> = {
+    (...features: QueryFeature<TArgs>[]): Query$1<TArgs>;
+    (queryConfig: QueryConfig$1, ...features: QueryFeature<TArgs>[]): Query$1<TArgs>;
+};
+type AnyQueryCreator$1 = QueryCreator$1<any>;
+type QueryArgsOf$1<T extends AnyQueryCreator$1 | AnyQuery$1> = T extends QueryCreator$1<infer TArgs> ? TArgs : T extends Query$1<infer TArgs> ? TArgs : never;
+type RunQueryCreator<TCreator extends AnyQueryCreator$1> = ReturnType<TCreator>;
+type QueryMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'TRACE' | 'CONNECT';
+type InternalCreateQueryCreatorOptions<TArgs extends QueryArgs> = {
+    /**
+     * The route of the query.
+     * If the query has path params, the route should be a function that takes the path params as an argument.
+     * Otherwise, it should be a string.
+     */
+    route: RouteType$1<TArgs>;
+    method: QueryMethod;
+    client: QueryClientConfig$1;
+};
+type QueryConfig$1 = {
+    /** A custom id to use for this query. Only affects queries that can be cached. */
+    key?: string;
+    /**
+     * If true, the query will not be executed automatically.
+     * Does not affect mutations such as POST, PUT etc. since those are never executed automatically.
+     */
+    onlyManualExecution?: boolean;
+    /**
+     * If true, the query will not throw an error because a "withArgs()" feature is missing.
+     */
+    silenceMissingWithArgsFeatureError?: boolean;
+    /**
+     * A custom injector to use for this query.
+     */
+    injector?: Injector;
+};
+declare const splitQueryConfig: <TArgs extends QueryArgs>(args: (QueryFeature<TArgs> | QueryConfig$1)[]) => {
+    features: QueryFeature<TArgs>[];
+    queryConfig: QueryConfig$1;
+};
+declare const createQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalCreateQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+
+type QueryArgs = {
+    response?: any;
+    pathParams?: Record<string, string | number>;
+    queryParams?: any;
+    body?: any;
+    headers?: HttpHeaders;
+};
+type ResponseType<T extends QueryArgs | null> = T extends QueryArgs ? T['response'] : never;
+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 CreateQueryOptions<TArgs extends QueryArgs> = {
+    creator?: CreateQueryCreatorOptions;
+    creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
+    features: QueryFeature<TArgs>[];
+    queryConfig: QueryConfig$1;
+};
+type QueryBase<TArgs extends QueryArgs> = {
+    /** The arguments of the last execution of the query. Will be `null` if the query has never been executed */
+    args: Signal<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.
+     */
+    response: Signal<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. */
+    latestHttpEvent: Signal<HttpEvent<ResponseType<TArgs>> | null>;
+    /** The loading state of the query. Will be `null` if the query currently isn't loading. */
+    loading: Signal<HttpRequestLoadingState | null>;
+    /** The error that occurred during the last execution of the query. Will be `null` if no error occurred. */
+    error: Signal<QueryErrorResponse | null>;
+    /** The time the query was last executed at. Will be `null` if the query has never been executed. */
+    lastTimeExecutedAt: Signal<number | null>;
+    /** The id of the query */
+    id: Signal<string>;
+    /** The current state of the query. Will be `null` if the query has never been executed. */
+    executionState: Signal<QueryExecutionState<TArgs> | null>;
+};
+/** A snapshot of a query state at a specific point in time */
+type QuerySnapshot<TArgs extends QueryArgs> = QueryBase<TArgs> & {
+    /** This signal is `true` until the latest execution of the query has completed in any way (success, error, or cancellation) */
+    isAlive: Signal<boolean>;
+};
+type AnyQuerySnapshot = QuerySnapshot<any>;
+type AnyQuery$1 = Query$1<any>;
+type QuerySubtle<TArgs extends QueryArgs> = {
+    /** Destroys the query and cleans up all resources. The query should not be used after this method is called. */
+    destroy: () => void;
+    /** Manually sets the response of the query. This will not trigger a new execution of the query. */
+    setResponse: (response: ResponseType<TArgs>) => void;
+    /** The currently underlying HTTP request of the query. Will be `null` if the query has never been executed. */
+    request: Signal<HttpRequest<TArgs> | null>;
+    /** The destroy reference used to clean up the query when it is no longer needed */
+    destroyRef: DestroyRef;
+    /** The Angular injector used to resolve dependencies for the query */
+    injector: Injector;
+};
+type Query$1<TArgs extends QueryArgs> = QueryBase<TArgs> & {
+    /** Executes the query */
+    execute: QueryExecute<TArgs>;
+    /** Creates an immutable snapshot of the current query state */
+    createSnapshot: () => QuerySnapshot<TArgs>;
+    /** Resets the query state to its initial state */
+    reset: () => void;
+    /** Returns a readonly version of the query */
+    asReadonly: () => ReadonlyQuery<TArgs>;
+    /** Advanced query features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
+    subtle: QuerySubtle<TArgs>;
+};
+type ReadonlyQuery<TArgs extends QueryArgs> = Omit<Query$1<TArgs>, 'execute' | 'subtle' | 'reset' | 'asReadonly'>;
+declare const createQuery: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => Query$1<TArgs>;
+
+declare const SPEED_BUFFER_TIME_IN_MS = 2000;
+type HttpRequestTransferCacheConfig = boolean | {
+    includeHeaders?: string[];
+};
+type HttpRequestResponseType = 'json' | 'text' | 'blob' | 'arraybuffer';
+type CreateHttpRequestDependencies = {
+    /** The http client instance to use for the request */
+    httpClient: HttpClient;
+    /** The error handler instance to use for the request */
+    ngErrorHandler: ErrorHandler;
+};
+type CreateHttpRequestClientOptions = {
+    /**
+     * Whether to report the progress of the request or not. If the fetch backend is used, this will only work for downloads.
+     * @see https://angular.dev/guide/http/making-requests#receiving-raw-progress-events
+     * @default false
+     */
+    reportProgress?: boolean;
+    /**
+     * Whether to include credentials in the request or not
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * This property accepts either a boolean to enable/disable transferring cache for eligible
+     * requests performed using `HttpClient`, or an object, which allows to configure cache
+     * parameters, such as which headers should be included (no headers are included by default).
+     *
+     * Setting this property will override the options passed to `provideClientHydration()` for this
+     * particular request
+     */
+    transferCache?: HttpRequestTransferCacheConfig;
+    /**
+     * The response type of the request
+     * @default 'json'
+     */
+    responseType?: HttpRequestResponseType;
+    /**
+     * The context of the request
+     * @default undefined
+     * @see https://angular.dev/guide/http/interceptors#request-and-response-metadata
+     */
+    context?: HttpContext;
+};
+type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
+    /** The HTTP method of the request */
+    method: QueryMethod;
+    /**
+     * The full path of the request
+     * @example 'https://api.example.com/v1/users'
+     */
+    fullPath: string;
+    /** The data of the request */
+    args?: RequestArgs<TArgs> | null;
+    /** The dependencies of the request */
+    dependencies: QueryRepositoryDependencies;
+    /** The client options of the request */
+    clientOptions?: CreateHttpRequestClientOptions;
+    /**
+     * The cache adapter function to use for the request
+     * @default extractExpiresInSeconds()
+     */
+    cacheAdapter?: CacheAdapterFn;
+    /**
+     * The retry function to use for the request
+     * @default shouldRetryRequest()
+     */
+    retryFn?: ShouldRetryRequestFn;
+};
+type HttpRequestLoadingState = {
+    /** The time when the request was executed in ms */
+    executeTime: number;
+    /** The progress of the request. Null if reportProgress is false or progress is not available / unsupported */
+    progress: HttpRequestLoadingProgressState | null;
+};
+type HttpRequestLoadingProgressState = {
+    /** The total number of bytes to be transferred */
+    total: number;
+    /** The number of bytes transferred */
+    loaded: number;
+    /** The percentage of the transfer that is completed */
+    percentage: number;
+    /** The speed of the transfer in bytes per millisecond */
+    speed: number | null;
+    /** The estimated remaining time in milliseconds */
+    remainingTime: number | null;
+};
+type HttpRequest<TArgs extends QueryArgs> = {
+    /** Executes the request */
+    execute: (options?: {
+        allowCache?: boolean;
+    }) => boolean;
+    /** Destroys the request (cancels it if in progress) */
+    destroy: () => boolean;
+    /** The loading state of the request */
+    loading: Signal<HttpRequestLoadingState | null>;
+    /** The error state of the request */
+    error: Signal<QueryErrorResponse | null>;
+    /** The response state of the request */
+    response: Signal<ResponseType<TArgs> | null>;
+    /** The current event of the request */
+    currentEvent: Signal<HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | null>;
+    /** Whether the request is stale or not aka the cache header has expired */
+    isStale: Signal<boolean>;
+};
+/** A custom error event since the Angular http client does not provide a specific event for errors */
+type HttpErrorEvent = {
+    type: 'error';
+    error: QueryErrorResponse;
+};
+declare const createHttpRequest: <TArgs extends QueryArgs>(options: CreateHttpRequestOptions<TArgs>) => HttpRequest<TArgs>;
+
+declare const ethletePaginationAdapter: <T>(response: Paginated<T>) => NormalizedPagination<T>;
+declare const ggLikePaginationAdapter: <T>(response: GgLikePaginated<T>) => NormalizedPagination<T>;
+declare const dynLikePaginationAdapter: <T>(response: DynLikePaginated<T>) => NormalizedPagination<T>;
+declare const contentfulGqlLikePaginationAdapter: <T>(response: ContentfulGqlLikePaginated<T>) => NormalizedPagination<T>;
+declare const fakePaginationAdapter: (totalHits?: number) => <T>(response: T) => NormalizedPagination<T>;
+type CreatePagedQueryStackOptions<TArgs extends QueryArgs, TNormPagination extends NormalizedPagination<unknown>> = {
+    /**
+     * The normalizer function that will be used to normalize the response to a format that the paged query can understand.
+     *
+     * There are some built-in normalizers that can be used:
+     * - `ethletePaginationAdapter`
+     * - `ggLikePaginationAdapter`
+     * - `dynLikePaginationAdapter`
+     * - `contentfulGqlLikePaginationAdapter`
+     * - `fakePaginationAdapter` (for testing purposes)
+     *
+     * @param currentResponse The current response that was fetched.
+     * @param allResponses All responses that were fetched till now including the current response and pagination.
+     */
+    responseNormalizer: (currentResponse: ResponseType<TArgs>, allResponses: NonNullable<ResponseType<TArgs>>[]) => TNormPagination;
+    /**
+     * The query creator function that will be used to create the paged query.
+     */
+    queryCreator: QueryCreator$1<TArgs>;
+    /**
+     * The arguments to create the query.
+     * The current page will be passed as an argument.
+     * This function can be treated like a computed function. It reacts to signal changes.
+     * If a signal changes, the paged query will be reset to the initial page.
+     *
+     * @example (page) => ({ queryParams: { page, limit:20 } }),
+     *
+     * @param page The page to fetch next. **Do not modify this argument.**
+     * @param allResponses All responses that were fetched till now including pagination.
+     */
+    args: (page: number, allResponses: NonNullable<ResponseType<TArgs>>[]) => RequestArgs<TArgs> | null;
+    /**
+     * The features that should be used for all queries in the stack.
+     *
+     * @throws If the `withArgs` feature is used. This feature is internally used.
+     *
+     * @example
+     * // Due to limitations in TypeScript, you have to manually add the needed generic types if needed.
+     * features: [E.withSuccessHandling<GetPostQueryArgs>({ handler: (post) => console.log(post.title) })]
+     *
+     * @example
+     * // If typings are not needed, you can use the feature without generics.
+     * features: [E.withPolling({ interval: 5000 })]
+     */
+    features?: QueryFeature<any>[];
+    /**
+     * The page to start this paged query from.
+     * @default 1
+     */
+    initialPage?: number;
+    /**
+     * If true, no queries will be executed while the paged query is loading.
+     * This is useful if you need the current response to be used in the next query.
+     */
+    blockExecutionDuringLoading?: boolean;
+};
+type PagedQueryStackResetOptions = {
+    /**
+     * The page to reset this paged query to.
+     * This will clear everything and start from this page.
+     * @default 1 // or the value passed in the `initialPage` option when creating the paged query.
+     */
+    initialPage?: number;
+};
+type PagedQueryStackExecuteOptions<TNormPagination extends NormalizedPagination<unknown>> = {
+    /**
+     * If provided, only the queries that match the condition will be executed.
+     * This will also execute the previous and next query to the one that matched the condition.
+     * If not provided, all queries will be executed.
+     *
+     * @example
+     * myPagedQuery.execute({ where: (item) => item.id === 4 });
+     */
+    where?: (item: TNormPagination['items'][number], index: number, array: TNormPagination['items']) => boolean;
+    /**
+     * If true, the cache will be used (if not expired) and the request will not be made.
+     * @default false
+     */
+    allowCache?: boolean;
+};
+type PagedQueryStackDirection = 'next' | 'previous';
+type AnyPagedQueryStack = PagedQueryStack<AnyQuery$1, NormalizedPagination<unknown>>;
+type PagedQueryStack<TQuery extends AnyQuery$1, TNormPagination extends NormalizedPagination<unknown>> = {
+    /**
+     * The pagination of the last executed query in the paged query.
+     */
+    maxPagination: Signal<TNormPagination | null>;
+    /**
+     * The pagination of the first executed query in the paged query.
+     */
+    minPagination: Signal<TNormPagination | null>;
+    /**
+     * Whether the last page of the paged query is loaded or not.
+     */
+    isLastPageLoaded: Signal<boolean>;
+    /**
+     * Whether the first page of the paged query is loaded or not.
+     */
+    isFirstPageLoaded: Signal<boolean>;
+    /**
+     * Fetches the previous page of the paged query.
+     *
+     * @throws If the paged query is already at the first page.
+     */
+    fetchPreviousPage: () => TQuery | null;
+    /**
+     * Fetches the next page of the paged query.
+     *
+     * @throws If the paged query is already at the last page.
+     */
+    fetchNextPage: () => TQuery | null;
+    /**
+     * Whether the previous page can be fetched or not.
+     *
+     * This will be false if the paged query is already at the first page or if the paged query is loading.
+     */
+    canFetchPreviousPage: Signal<boolean>;
+    /**
+     * Whether the next page can be fetched or not.
+     *
+     * This will be false if the paged query is already at the last page or if the paged query is loading.
+     */
+    canFetchNextPage: Signal<boolean>;
+    /**
+     * The items of the paged query.
+     */
+    items: Signal<TNormPagination['items']>;
+    /**
+     * Whether the paged query is loading or not.
+     */
+    loading: Signal<boolean>;
+    /**
+     * The error that occurred during the last execution of the paged query.
+     */
+    error: Signal<QueryErrorResponse | null>;
+    /**
+     * The last query executed in the paged query.
+     */
+    lastQuery: Signal<Query$1<QueryArgsOf$1<TQuery>> | null>;
+    /**
+     * Whether the paged query is on its first load or not.
+     */
+    isFirstLoad: Signal<boolean>;
+    /**
+     * The queries in the paged query stack.
+     */
+    queries: Signal<TQuery[]>;
+    /**
+     * Resets the paged query to the initial page.
+     */
+    reset: (resetOptions?: PagedQueryStackResetOptions) => void;
+    /**
+     * Executes the paged query.
+     */
+    execute: (options?: PagedQueryStackExecuteOptions<TNormPagination>) => void;
+    /**
+     * The current direction of the paged query.
+     */
+    direction: Signal<PagedQueryStackDirection>;
+};
+declare const createPagedQueryStack: <TCreator extends AnyQueryCreator$1, TArgs extends QueryArgsOf$1<TCreator>, TNormPagination extends NormalizedPagination<unknown>>(options: CreatePagedQueryStackOptions<TArgs, TNormPagination>) => PagedQueryStack<Query$1<TArgs>, TNormPagination>;
+
+/** A query creator that creates a GET query */
+declare const createGetQuery: (client: QueryClientConfig$1) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a secure GET query (requires authentication) */
+declare const createSecureGetQuery: (client: QueryClientConfig$1, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a POST query */
+declare const createPostQuery: (client: QueryClientConfig$1) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a secure POST query (requires authentication) */
+declare const createSecurePostQuery: (client: QueryClientConfig$1, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a PUT query */
+declare const createPutQuery: (client: QueryClientConfig$1) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a secure PUT query (requires authentication) */
+declare const createSecurePutQuery: (client: QueryClientConfig$1, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a DELETE query */
+declare const createDeleteQuery: (client: QueryClientConfig$1) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a secure DELETE query (requires authentication) */
+declare const createSecureDeleteQuery: (client: QueryClientConfig$1, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a PATCH query */
+declare const createPatchQuery: (client: QueryClientConfig$1) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+/** A query creator that creates a secure PATCH query (requires authentication) */
+declare const createSecurePatchQuery: (client: QueryClientConfig$1, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType$1<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => QueryCreator$1<TArgs>;
+
+declare const enum QueryRuntimeErrorCode {
+    QUERY_FEATURE_USED_MULTIPLE_TIMES = 0,
+    WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION = 100,
+    WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD = 101,
+    WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD = 102,
+    WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY = 103,
+    SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT = 104,
+    COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED = 200,
+    ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 201,
+    DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 202,
+    LOGIN_CALLED_WITHOUT_CONFIG = 203,
+    LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG = 204,
+    REFRESH_TOKEN_CALLED_WITHOUT_CONFIG = 205,
+    SELECT_ROLE_CALLED_WITHOUT_CONFIG = 206,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT = 207,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN = 208,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN = 209,
+    UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,
+    BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,
+    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM = 300,
+    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM = 301,
+    PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES = 400,
+    PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE = 401,
+    PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE = 402,
+    QUERY_STACK_WITH_ARGS_USED = 500,
+    QUERY_STACK_WITH_RESPONSE_UPDATE_USED = 501,
+    QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH = 502
+}
+declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
+declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
+declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY>;
+declare const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent: () => RuntimeError<QueryRuntimeErrorCode.SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT>;
+declare const cookieLoginTriedButCookieDisabled: () => RuntimeError<QueryRuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED>;
+declare const enableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+declare const disableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+declare const loginCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG>;
+declare const loginWithTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG>;
+declare const refreshTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG>;
+declare const selectRoleCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG>;
+declare const defaultResponseTransformerResponseNotObject: (currentType: string) => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT>;
+declare const defaultResponseTransformerResponseNotContainingAccessToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN>;
+declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN>;
+declare const unableToDecryptBearerToken: (token: string) => RuntimeError<QueryRuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
+declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<QueryRuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;
+declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM>;
+declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM>;
+declare const pagedQueryStackPageBiggerThanTotalPages: (page: number, totalPages: number) => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES>;
+declare const pagedQueryStackNextPageCalledWithoutPreviousPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE>;
+declare const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE>;
+declare const queryStackWithArgsUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED>;
+declare const queryStackWithResponseUpdateUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED>;
+declare const queryStackTotalQueriesAndExpectedQueriesMismatch: (totalQueries: number, expectedQueries: number) => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH>;
+
+type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
+    state: QueryState$1<TArgs>;
+    deps: QueryDependencies;
+    execute: InternalQueryExecute<TArgs>;
+};
+declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;
+
+type QueryStackSubtle<TCreator extends AnyQueryCreator$1, TQuery extends AnyQuery$1> = {
+    /** Create a new query with the given arguments. You should always prefer the `args` option instead of this. */
+    runWithArgs: (args: RequestArgs<QueryArgsOf$1<TCreator>> | RequestArgs<QueryArgsOf$1<TCreator>>[] | null) => TQuery | null;
+};
+type QueryStack<TQuery extends AnyQuery$1, TCreator extends AnyQueryCreator$1, TTransform> = {
+    /** Contains all queries in the stack. */
+    queries: Signal<TQuery[]>;
+    /** Contains the first query in the stack. */
+    firstQuery: Signal<TQuery | null>;
+    /** Contains the last query in the stack. Useful for getting current pagination values. */
+    lastQuery: Signal<TQuery | null>;
+    /** True if any query in the stack is loading. */
+    loading: Signal<boolean>;
+    /** Contains the first error that occurred in the stack. */
+    error: Signal<QueryErrorResponse | null>;
+    /** Contains the responses of all queries in the stack. Will be `null` for queries that are loading or errored. */
+    response: Signal<TTransform>;
+    /** Executes all queries in the stack. */
+    execute: (options?: {
+        allowCache?: boolean;
+    }) => void;
+    /** Destroys all queries in the stack and empties it. This should only be used if `append` is true. */
+    clear: () => void;
+    /** Advanced query stack features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
+    subtle: QueryStackSubtle<TCreator, TQuery>;
+};
+type AnyQueryStack = QueryStack<AnyQuery$1, AnyQueryCreator$1, any>;
+type CreateQueryStackOptions<TCreator extends AnyQueryCreator$1, TDeps extends () => any, TTransform = (ResponseType<QueryArgsOf$1<TCreator>> | null)[]> = {
+    /**
+     * The query creator function that will be used to create the query stack.
+     */
+    queryCreator: TCreator;
+    /**
+     * The dependencies that should trigger a new query stack creation.
+     * This function can be treated like a computed function. It reacts to signal changes.
+     * The return value of this function will be passed to the `args` function.
+     *
+     * This option can be ignored if `append` is false.
+     */
+    dependencies?: TDeps;
+    /**
+     * The features that should be used for all queries in the stack.
+     *
+     * @throws If the `withArgs` feature is used. This feature is internally used.
+     *
+     * @example
+     * // Due to limitations in TypeScript, you have to manually add the needed generic types if needed.
+     * features: [E.withSuccessHandling<GetPostQueryArgs>({ handler: (post) => console.log(post.title) })]
+     *
+     * @example
+     * // If typings are not needed, you can use the feature without generics.
+     * features: [E.withPolling({ interval: 5000 })]
+     */
+    features?: QueryFeature<any>[];
+    /**
+     * The arguments to create queries with.
+     * This function can be treated like a computed function. It reacts to signal changes.
+     * If a signal changes, a new query will be created (and appended to the existing ones if `append` is true).
+     * If this function returns `null`, the args will be ignored.
+     * If this function returns an array, multiple queries will be created.
+     *
+     * @example
+     * // One query
+     * () => ({ queryParams: { postId: myId() } }),
+     *
+     * @example
+     * // Multiple queries (these can of cause also be created using a loop)
+     * () => [
+     *  { queryParams: { postId: myId() } },
+     *  { queryParams: { postId: myOtherId() } },
+     * ],
+     *
+     * @example
+     * // One query with dependencies
+     * (deps) => ({ queryParams: { postId: myId(), limit: deps.limit } }),
+     */
+    args: (deps: ReturnType<TDeps>) => RequestArgs<QueryArgsOf$1<TCreator>> | RequestArgs<QueryArgsOf$1<TCreator>>[] | null;
+    /**
+     * If true, new queries will be appended to the existing ones. Otherwise, existing queries will be destroyed.
+     * This should be used for things like infinite scrolling where already fetched queries should not be destroyed.
+     */
+    append?: boolean;
+    /**
+     * If append is true, this function will be called to merge the old and new queries.
+     * Useful if you want to append the new queries in a specific order (e.g. at the beginning).
+     */
+    appendFn?: (oldQueries: RunQueryCreator<TCreator>[], newQueries: RunQueryCreator<TCreator>[]) => {
+        /** The new queries merged with the old ones. */
+        queries: RunQueryCreator<TCreator>[];
+        /** The last query in the new queries. */
+        lastQuery: RunQueryCreator<TCreator> | null;
+    };
+    /**
+     * Transforms the responses of all queries in the stack. Useful for merging or filtering responses.
+     */
+    transform?: (responses: ResponseType<QueryArgsOf$1<TCreator>>[]) => TTransform;
+};
+/** Transforms an array of arrays into a single array and filters out `null` values. */
+declare const transformArrayResponse: <T extends (unknown | null)[]>(responses: T) => NonNullable<T[0]>[];
+/** Transforms an array of paginated responses into a single array and filters out `null` values. */
+declare const transformPaginatedResponse: <T extends ({
+    items: unknown[];
+} | null)[]>(responses: T) => NonNullable<NonNullable<T[0]>["items"]>;
+declare const createQueryStack: <TCreator extends AnyQueryCreator$1, TArgs extends QueryArgsOf$1<TCreator>, TDeps extends () => any, TTransform = (ResponseType<TArgs> | null)[]>(options: CreateQueryStackOptions<TCreator, TDeps, TTransform>) => QueryStack<RunQueryCreator<TCreator>, TCreator, TTransform>;
+
+type InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs> & {
+    authProvider: AnyBearerAuthProviderConfig;
+};
+declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalSecureCreateQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+
+type CreateSecureQueryOptions<TArgs extends QueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creatorInternals'> & {
+    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
+};
+declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => Query$1<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 BearerAuthProviderTokens = {
+    accessToken: string;
+    refreshToken: string;
+};
+type BearerAuthProviderRouteConfig<TArgs extends QueryArgs> = {
+    queryCreator: QueryCreator$1<TArgs>;
+    /**
+     * A function that transforms the response into the format that the auth provider expects
+     *
+     * The expected format is an object with the `accessToken` and `refreshToken` properties.
+     *
+     * @default (response) => response
+     */
+    responseTransformer?: (response: ResponseType<TArgs>) => BearerAuthProviderTokens;
+};
+type BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs> = {
+    /**
+     * The cookie name where the refresh token is stored
+     * @default 'etAuth'
+     */
+    name?: string;
+    /**
+     * The domain of the cookie. If not set, the current origin will be used.
+     *
+     * @example
+     * "https://example.com" -> "example.com"
+     * "https://sub.example.com" -> "example.com"
+     */
+    domain?: string;
+    /**
+     * The days until the cookie expires
+     * @default 30
+     */
+    expiresInDays?: number;
+    /**
+     * The path of the cookie
+     * @default '/'
+     */
+    path?: string;
+    /**
+     * Enable or disable the cookie
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * The same site property of the cookie
+     * @default 'lax'
+     */
+    sameSite?: 'strict' | 'none' | 'lax';
+    /**
+     * A function that turns the token gotten from the cookie into the body for the refresh token request
+     * @default (token) => ({ token })
+     */
+    refreshArgsTransformer?: (token: string) => RequestArgs<TTokenRefreshArgs>;
+    /**
+     * An array of routes where the auto login via cookie should not be triggered.
+     *
+     * This checks the current route against the array of routes using the `startsWith` method.
+     * Make sure to start each route with a `/`.
+     *
+     * @default []
+     * @example ['/login', '/register']
+     */
+    autoLoginExcludeRoutes?: string[];
+};
+type CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = {
+    /**
+     * The name of the auth provider
+     */
+    name: string;
+    /**
+     * The query client reference
+     */
+    queryClientRef: QueryClientRef;
+    /**
+     * The login route configuration
+     */
+    login?: BearerAuthProviderRouteConfig<TLoginArgs>;
+    /**
+     * The token login route configuration
+     */
+    tokenLogin?: BearerAuthProviderRouteConfig<TTokenLoginArgs>;
+    /**
+     * The token refresh route configuration
+     */
+    tokenRefresh?: BearerAuthProviderRouteConfig<TTokenRefreshArgs>;
+    /**
+     * The select role route configuration
+     */
+    selectRole?: BearerAuthProviderRouteConfig<TSelectRoleArgs>;
+    /**
+     * The cookie configuration for the auth provider
+     */
+    cookie?: BearerAuthProviderCookieConfig<TTokenRefreshArgs>;
+    /**
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 // (5 minutes)
+     */
+    refreshBuffer?: number;
+    /**
+     * The expires in property name inside the jwt body
+     * @default 'exp'
+     */
+    expiresInPropertyName?: string;
+    /**
+     * Determines if the token should be refreshed if **any** query returns a 401 response.
+     * @default true
+     */
+    refreshOnUnauthorizedResponse?: boolean;
+    /**
+     * A function that decrypts the bearer token
+     */
+    bearerDecryptFn?: (token: string) => TBearerData;
+};
+type BearerAuthProviderConfig<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData> & {
+    token: BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+};
+type AnyBearerAuthProviderConfig = BearerAuthProviderConfig<any, any, any, any, any>;
+type BearerAuthProviderRef<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = InjectionToken<BearerAuthProvider$1<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>>;
+declare const createBearerAuthProviderConfig: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(options: CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+
+type QuerySnapshotWithType<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = ({
+    type: 'login';
+} & QuerySnapshot<TLoginArgs>) | ({
+    type: 'tokenLogin';
+} & QuerySnapshot<TTokenLoginArgs>) | ({
+    type: 'tokenRefresh';
+} & QuerySnapshot<TTokenRefreshArgs>) | ({
+    type: 'selectRole';
+} & QuerySnapshot<TSelectRoleArgs>);
+type BearerAuthProvider$1<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = {
+    /**
+     * Logs in the user with the given args.
+     */
+    login: (args: RequestArgs<TLoginArgs>) => QuerySnapshot<TLoginArgs>;
+    /**
+     * Logs in the user with the given token.
+     */
+    loginWithToken: (args: RequestArgs<TTokenLoginArgs>) => QuerySnapshot<TTokenLoginArgs>;
+    /**
+     * Refreshes the token with the given refresh token.
+     */
+    refreshToken: (args: RequestArgs<TTokenRefreshArgs>) => QuerySnapshot<TTokenRefreshArgs>;
+    /**
+     * Selects the role for the user.
+     */
+    selectRole: (args: RequestArgs<TSelectRoleArgs>) => QuerySnapshot<TSelectRoleArgs>;
+    /**
+     * Logs out the user and removes the cookie.
+     */
+    logout: () => void;
+    /**
+     * Enables cookie usage for the auth provider.
+     */
+    enableCookie: () => void;
+    /**
+     * Disables cookie usage for the auth provider and removes the cookie.
+     */
+    disableCookie: () => void;
+    /**
+     * Checks if the cookie is present.
+     */
+    isCookiePresent: () => boolean;
+    /**
+     * Tries to login with the given cookie config.
+     * Returns `true` if a cookie was found, `false` otherwise.
+     */
+    tryLoginWithCookie: () => boolean;
+    /**
+     * The latest executed query that was not triggered internally.
+     */
+    latestExecutedQuery: Signal<QuerySnapshotWithType<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs> | null>;
+    /**
+     * A signal that contains the current access and refresh tokens.
+     */
+    tokens: Signal<BearerAuthProviderTokens | null>;
+    /**
+     * The bearer data that was decrypted from the access token.
+     */
+    bearerData: Signal<TBearerData | null>;
+};
+declare const createBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(options: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => BearerAuthProvider$1<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+declare const provideBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData>(config: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>) => {
+    provide: BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+    useFactory: () => BearerAuthProvider$1<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+};
+
+type TransformedGqlQuery = {
+    query: string;
+    variables?: string;
+    operationName?: string;
+};
+declare const transformGql: (str: string) => (variables: Record<string, unknown> | null | undefined) => TransformedGqlQuery;
+type GQL = string & {
+    gql: 'tag';
+};
+declare const gql: (strings: TemplateStringsArray, ...values: string[]) => GQL;
+
+/** A query creator that creates a GQL query where the payload is sent via GET (query params) */
+declare const createGqlQueryViaGet: (client: QueryClientConfig$1) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+/** A query creator that creates a GQL query where the payload is sent via POST (body) */
+declare const createGqlQueryViaPost: (client: QueryClientConfig$1) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+/** A query creator that creates a GQL mutation where the payload is sent via GET (query params) */
+declare const createGqlMutationViaGet: (client: QueryClientConfig$1) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+/** A query creator that creates a GQL mutation where the payload is sent via POST (body) */
+declare const createGqlMutationViaPost: (client: QueryClientConfig$1) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => QueryCreator$1<TArgs>;
+
+type CreateGqlQueryExecuteOptions<TArgs extends QueryArgs> = {
+    deps: QueryDependencies;
+    state: QueryState$1<TArgs>;
+    creator?: CreateGqlQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateGqlQueryCreatorOptions;
+    queryConfig: QueryConfig$1;
+};
+declare const createGqlExecuteFn: <TArgs extends GqlQueryArgs>(executeOptions: CreateGqlQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;
+
+type CreateLegacyQueryOptions<TArgs extends QueryArgs> = {
+    query: Query$1<TArgs>;
+};
+declare const isLegacyQuery: <T extends AnyLegacyQuery>(query: unknown) => query is T;
+type AnyLegacyQuery = LegacyQuery<any, any, any, any, any, any, any>;
+declare class LegacyQuery<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery$1> {
+    newQuery: TNewQuery;
+    _arguments: RequestArgs<QueryArgsOf$1<TNewQuery>>;
+    entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined;
+    state$: Observable<QueryState<Data>>;
+    get rawState(): QueryState<any>;
+    get isExpired(): boolean | undefined;
+    get isInUse(): boolean;
+    get isPolling(): boolean;
+    get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
+    get store(): null;
+    get canBeCached(): boolean;
+    get _isInMockMode(): boolean;
+    constructor(newQuery: TNewQuery, _arguments: RequestArgs<QueryArgsOf$1<TNewQuery>>, entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id> | undefined);
+    destroy(): void;
+    execute(options?: ExecuteQueryOptions): this;
+    abort(): this;
+    poll(config: PollConfig): this;
+    stopPolling(): this;
+    pausePolling(): this;
+    resumePolling(): this;
+    onSuccess(callback: (response: Data) => void): this;
+    onFailure(callback: (error: RequestError<unknown>) => void): this;
+}
+
+interface QueryContainerConfig {
+    /**
+     * If `true`, the previous query will be aborted when a new query is pushed into the container.
+     * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    abortPrevious?: boolean;
+    /**
+     * If `true`, the query will be aborted when the container is destroyed.
+     * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    abortOnDestroy?: boolean;
+    /**
+     * If `true`, the previous polling will be stopped when a new query is pushed into the container.
+     * @default true // Only if the query has no other dependents and the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    stopPreviousPolling?: boolean;
+}
+interface QueryFilterConfig {
+    /**
+     * If `true`, the response will be cached until the next response is received or the query fails.
+     * @default false
+     */
+    cacheResponse?: boolean;
+}
+declare const addQueryContainerHandling: (obs: Observable<AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null>, valueFn: () => AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null | undefined, config?: QueryContainerConfig) => void;
+declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
+    initialValue?: undefined;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | undefined>;
+declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
+    initialValue?: null;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | null>;
+declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
+    initialValue?: undefined;
+    requireSync: true;
+} & QueryContainerConfig): Signal<T>;
+declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
+    initialValue: U;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | U>;
+declare function effectComputed<T extends AnyQuery | AnyLegacyQuery | AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, injector: Injector): Signal<T>;
+declare function queryComputed<T extends AnyQuery | AnyLegacyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+/**
+ * Creates a signal that will only be reactive until the first query is created.
+ * All subsequent changes inside the computation will be ignored.
+ */
+declare function queryComputedTillTruthy<T extends AnyQuery | AnyLegacyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
+declare function queryArrayComputed<T extends AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+declare function toQuerySubject<T extends AnyQuery | AnyLegacyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
+declare function queryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): _angular_core.WritableSignal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+type QueryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>> = Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null> & {
+    reset: () => void;
+};
+declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): QueryStateSignal<T>;
+declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<_ethlete_query.RequestError<unknown> | null>;
+declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<Loading | null>;
+
+declare const deepFreeze: <T extends Record<string, unknown>>(object: T) => T;
+
+/**
+ * Dummy function for providing types while not breaking inference.
+ * **This function always returns null.**
+ * @see https://github.com/microsoft/TypeScript/issues/26242
+ * @returns null
+ */
+declare const def: <Data>() => Data;
+
+type LegacyArgumentsOfQueryArgs<T extends QueryArgs> = Omit<T, 'response' | 'headers'> & WithHeaders;
+type QueryArgsOfLegacyArguments<T extends BaseArguments | undefined, J> = Omit<T, 'mock' | 'headers'> & {
+    headers?: HttpHeaders;
+    response?: J;
+};
+type CreateLegacyQueryCreatorOptions<TArgs extends QueryArgs, Response, Store extends EntityStore<unknown>, Data, Id> = {
+    creator: QueryCreator$1<TArgs>;
+    /**
+     * Object containing the query's entity store information.
+     */
+    entity?: QueryEntityConfig<Store, Data, Response, LegacyArgumentsOfQueryArgs<TArgs>, Id>;
+};
+interface WithLegacyConfig {
+    /**
+     * Additional configuration for this query.
+     */
+    config?: QueryConfig & {
+        /**
+         * If set to true, the query will be destroyed when it either succeeds or fails.
+         */
+        destroyOnResponse?: boolean;
+    };
+}
+type LegacyQueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery$1> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders & WithLegacyConfig & WithInjector) => LegacyQuery<Response, Arguments, Route, Store, Data, Id, TNewQuery> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithLegacyConfig & WithInjector) => LegacyQuery<Response, Arguments, Route, Store, Data, Id, TNewQuery>;
+type AnyLegacyQueryCreator = LegacyQueryCreator<any, any, any, any, any>;
+/**
+ * Creates a legacy query creator.
+ * @deprecated This is a temporary solution to support legacy queries. It will be removed in the future.
+ */
+declare class LegacyQueryCreator<TArgs extends QueryArgs, Response extends ResponseType<TArgs>, Store extends EntityStore<unknown>, Id, Data = Response> {
+    options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>;
+    constructor(options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>);
+    prepare: LegacyQueryPrepareFn<LegacyArgs, Response, Route, Store, Data, Id, Query$1<TArgs>>;
+    createSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query$1<TArgs>> | null>;
+    createSignal: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => _angular_core.WritableSignal<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query$1<TArgs>> | null>;
+    behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgs, Route, Store, Data, Id, Query$1<TArgs>> | null>;
+}
+declare const createLegacyQueryCreator: <TArgs extends QueryArgs, Response extends ResponseType<TArgs>, Store extends EntityStore<unknown>, Id, Data = Response>(options: CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>) => LegacyQueryCreator<TArgs, Response, Store, Id, Data>;
+
+declare const parseHttpErrorCodeToTitleDe: (statusCode: HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Weg" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Bereich nicht zufriedenstellend" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
+declare const parseHttpErrorCodeToMessageDe: (statusCode: HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
+
+declare class ParseHttpErrorCodeToTitleDePipe implements PipeTransform {
+    transform: (statusCode: _angular_common_module_d_yNBsZ8gb.HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Weg" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Bereich nicht zufriedenstellend" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleDePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleDePipe, "parseHttpErrorCodeToTitleDe", true>;
+}
+declare class ParseHttpErrorCodeToMessageDePipe implements PipeTransform {
+    transform: (statusCode: _angular_common_module_d_yNBsZ8gb.HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageDePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageDePipe, "parseHttpErrorCodeToMessageDe", true>;
+}
+
+declare const parseHttpErrorCodeToTitleEn: (statusCode: HttpStatusCode) => "Bad request" | "Unauthorized" | "Payment required" | "Forbidden" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Range not satisfiable" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
+declare const parseHttpErrorCodeToMessageEn: (statusCode: HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The client has asked for a portion of the file, but the server cannot supply that portion." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server is unwilling to process the request because the user has not been authenticated." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
+
+declare class ParseHttpErrorCodeToTitleEnPipe implements PipeTransform {
+    transform: (statusCode: _angular_common_module_d_yNBsZ8gb.HttpStatusCode) => "Bad request" | "Unauthorized" | "Payment required" | "Forbidden" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Range not satisfiable" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleEnPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleEnPipe, "parseHttpErrorCodeToTitleEn", true>;
+}
+declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
+    transform: (statusCode: _angular_common_module_d_yNBsZ8gb.HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The client has asked for a portion of the file, but the server cannot supply that portion." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server is unwilling to process the request because the user has not been authenticated." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageEnPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageEnPipe, "parseHttpErrorCodeToMessageEn", true>;
+}
+
+type CreateWebSocketClientTransport = 'polling' | 'websocket' | 'webtransport';
+type CreateWebSocketClientConfig = {
+    /** A unique name for the client */
+    name: string;
+    /** The URL of the socket io server */
+    url: string;
+    /** A list of transports to try (in order). Engine.io always attempts to connect directly with the first one, provided the feature detection test for it passes. */
+    transports?: CreateWebSocketClientTransport[];
+};
+type WebSocketClientRef<TMessageData extends SocketMessageView = SocketMessageView> = InjectionToken<WebSocketClient<TMessageData>>;
+type WebSocketClientConfig = CreateWebSocketClientConfig & {
+    /** A generated token for dependency injection */
+    token: WebSocketClientRef;
+};
+declare const createWebSocketClientConfig: (options: CreateWebSocketClientConfig) => WebSocketClientConfig;
+
+/** A default socket io message view */
+type SocketMessageView<TMessageData = unknown> = {
+    room: string;
+    event: string;
+    data: TMessageData;
+};
+type WebSocketClientSubtle = {
+    /** Leave a socket io room */
+    leaveRoom: (room: string) => void;
+};
+type WebSocketClient<TMessageData extends SocketMessageView> = {
+    /**
+     * Join a socket io room
+     * If a function is passed, it will be evaluated in a reactive signal context.
+     * If the function returns null, no room will be joined.
+     * If the function returns a string, the previous room will be left and the new room will be joined.
+     */
+    joinRoom: (room: string | (() => string | null)) => Signal<WebSocketRoom<TMessageData> | null>;
+    /** Whether the client is connected to the server */
+    isConnected: Signal<boolean>;
+    /** Advanced web socket features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
+    subtle: WebSocketClientSubtle;
+};
+type InternalWebSocketRoom<TMessageData extends SocketMessageView> = {
+    latestMessage: WritableSignal<TMessageData | null>;
+};
+type WebSocketRoom<TMessageData extends SocketMessageView> = {
+    /** The latest message received in the room */
+    latestMessage: Signal<TMessageData | null>;
+};
+declare const createWebSocketClient: <TMessageData extends SocketMessageView>(config: WebSocketClientConfig) => WebSocketClient<TMessageData>;
+declare const provideWebSocketClient: (config: WebSocketClientConfig) => {
+    provide: WebSocketClientRef<SocketMessageView>;
+    useFactory: () => WebSocketClient<SocketMessageView<unknown>>;
+};
+
+type index_d_AnyBearerAuthProviderConfig = AnyBearerAuthProviderConfig;
+type index_d_AnyLegacyQuery = AnyLegacyQuery;
+type index_d_AnyLegacyQueryCreator = AnyLegacyQueryCreator;
+type index_d_AnyPagedQueryStack = AnyPagedQueryStack;
+type index_d_AnyQuerySnapshot = AnyQuerySnapshot;
+type index_d_AnyQueryStack = AnyQueryStack;
+type index_d_BearerAuthProviderConfig<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+type index_d_BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs> = BearerAuthProviderCookieConfig<TTokenRefreshArgs>;
+type index_d_BearerAuthProviderRef<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+type index_d_BearerAuthProviderRouteConfig<TArgs extends QueryArgs> = BearerAuthProviderRouteConfig<TArgs>;
+type index_d_BearerAuthProviderTokens = BearerAuthProviderTokens;
+type index_d_BodyType<T extends QueryArgs | null> = BodyType<T>;
+declare const index_d_CLEAR_QUERY_ARGS: typeof CLEAR_QUERY_ARGS;
+type index_d_CacheAdapterFn = CacheAdapterFn;
+type index_d_CleanupPreviousExecuteOptions<TArgs extends QueryArgs> = CleanupPreviousExecuteOptions<TArgs>;
+type index_d_ClearQueryArgs = ClearQueryArgs;
+type index_d_CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs, TBearerData> = CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs, TBearerData>;
+type index_d_CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = CreateGqlQueryCreatorOptions<TArgs>;
+type index_d_CreateGqlQueryExecuteOptions<TArgs extends QueryArgs> = CreateGqlQueryExecuteOptions<TArgs>;
+type index_d_CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = CreateGqlQueryOptions<TArgs>;
+type index_d_CreateHttpRequestClientOptions = CreateHttpRequestClientOptions;
+type index_d_CreateHttpRequestDependencies = CreateHttpRequestDependencies;
+type index_d_CreateHttpRequestOptions<TArgs extends QueryArgs> = CreateHttpRequestOptions<TArgs>;
+type index_d_CreateLegacyQueryCreatorOptions<TArgs extends QueryArgs, Response, Store extends EntityStore<unknown>, Data, Id> = CreateLegacyQueryCreatorOptions<TArgs, Response, Store, Data, Id>;
+type index_d_CreateLegacyQueryOptions<TArgs extends QueryArgs> = CreateLegacyQueryOptions<TArgs>;
+type index_d_CreatePagedQueryStackOptions<TArgs extends QueryArgs, TNormPagination extends NormalizedPagination<unknown>> = CreatePagedQueryStackOptions<TArgs, TNormPagination>;
+type index_d_CreateQueryClientConfigOptions = CreateQueryClientConfigOptions;
+type index_d_CreateQueryCreatorOptions = CreateQueryCreatorOptions;
+type index_d_CreateQueryExecuteOptions<TArgs extends QueryArgs> = CreateQueryExecuteOptions<TArgs>;
+type index_d_CreateQueryObjectOptions<TArgs extends QueryArgs> = CreateQueryObjectOptions<TArgs>;
+type index_d_CreateQueryOptions<TArgs extends QueryArgs> = CreateQueryOptions<TArgs>;
+type index_d_CreateQueryRepositoryConfig = CreateQueryRepositoryConfig;
+type index_d_CreateQuerySnapshotOptions<TArgs extends QueryArgs> = CreateQuerySnapshotOptions<TArgs>;
+type index_d_CreateQueryStackOptions<TCreator extends AnyQueryCreator$1, TDeps extends () => any, TTransform = (ResponseType<QueryArgsOf$1<TCreator>> | null)[]> = CreateQueryStackOptions<TCreator, TDeps, TTransform>;
+type index_d_CreateSecureQueryExecuteOptions<TArgs extends QueryArgs> = CreateSecureQueryExecuteOptions<TArgs>;
+type index_d_CreateSecureQueryOptions<TArgs extends QueryArgs> = CreateSecureQueryOptions<TArgs>;
+type index_d_CreateWebSocketClientConfig = CreateWebSocketClientConfig;
+type index_d_CreateWebSocketClientTransport = CreateWebSocketClientTransport;
+type index_d_GqlQueryArgs = GqlQueryArgs;
+type index_d_GqlQueryMethod = GqlQueryMethod;
+type index_d_GqlQueryTransport = GqlQueryTransport;
+type index_d_GqlVariablesType<T extends GqlQueryArgs | null> = GqlVariablesType<T>;
+type index_d_HttpErrorEvent = HttpErrorEvent;
+type index_d_HttpRequest<TArgs extends QueryArgs> = HttpRequest<TArgs>;
+type index_d_HttpRequestLoadingProgressState = HttpRequestLoadingProgressState;
+type index_d_HttpRequestLoadingState = HttpRequestLoadingState;
+type index_d_HttpRequestResponseType = HttpRequestResponseType;
+type index_d_HttpRequestTransferCacheConfig = HttpRequestTransferCacheConfig;
+type index_d_InternalCreateGqlQueryCreatorOptions = InternalCreateGqlQueryCreatorOptions;
+type index_d_InternalCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs>;
+type index_d_InternalQueryExecute<TArgs extends QueryArgs> = InternalQueryExecute<TArgs>;
+type index_d_InternalRunQueryExecuteOptions = InternalRunQueryExecuteOptions;
+type index_d_InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalSecureCreateQueryCreatorOptions<TArgs>;
+type index_d_InternalWebSocketRoom<TMessageData extends SocketMessageView> = InternalWebSocketRoom<TMessageData>;
+type index_d_LegacyArgumentsOfQueryArgs<T extends QueryArgs> = LegacyArgumentsOfQueryArgs<T>;
+type index_d_LegacyQuery<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery$1> = LegacyQuery<Response, Arguments, Route, Store, Data, Id, TNewQuery>;
+declare const index_d_LegacyQuery: typeof LegacyQuery;
+type index_d_LegacyQueryCreator<TArgs extends QueryArgs, Response extends ResponseType<TArgs>, Store extends EntityStore<unknown>, Id, Data = Response> = LegacyQueryCreator<TArgs, Response, Store, Id, Data>;
+declare const index_d_LegacyQueryCreator: typeof LegacyQueryCreator;
+type index_d_LegacyQueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id, TNewQuery extends AnyQuery$1> = LegacyQueryPrepareFn<Arguments, Response, Route, Store, Data, Id, TNewQuery>;
+type index_d_PagedQueryStack<TQuery extends AnyQuery$1, TNormPagination extends NormalizedPagination<unknown>> = PagedQueryStack<TQuery, TNormPagination>;
+type index_d_PagedQueryStackDirection = PagedQueryStackDirection;
+type index_d_PagedQueryStackExecuteOptions<TNormPagination extends NormalizedPagination<unknown>> = PagedQueryStackExecuteOptions<TNormPagination>;
+type index_d_PagedQueryStackResetOptions = PagedQueryStackResetOptions;
+type index_d_ParseHttpErrorCodeToMessageDePipe = ParseHttpErrorCodeToMessageDePipe;
+declare const index_d_ParseHttpErrorCodeToMessageDePipe: typeof ParseHttpErrorCodeToMessageDePipe;
+type index_d_ParseHttpErrorCodeToMessageEnPipe = ParseHttpErrorCodeToMessageEnPipe;
+declare const index_d_ParseHttpErrorCodeToMessageEnPipe: typeof ParseHttpErrorCodeToMessageEnPipe;
+type index_d_ParseHttpErrorCodeToTitleDePipe = ParseHttpErrorCodeToTitleDePipe;
+declare const index_d_ParseHttpErrorCodeToTitleDePipe: typeof ParseHttpErrorCodeToTitleDePipe;
+type index_d_ParseHttpErrorCodeToTitleEnPipe = ParseHttpErrorCodeToTitleEnPipe;
+declare const index_d_ParseHttpErrorCodeToTitleEnPipe: typeof ParseHttpErrorCodeToTitleEnPipe;
+type index_d_PathParamsType<T extends QueryArgs | null> = PathParamsType<T>;
+type index_d_QueryArgs = QueryArgs;
+type index_d_QueryArgsOfLegacyArguments<T extends BaseArguments | undefined, J> = QueryArgsOfLegacyArguments<T, J>;
+type index_d_QueryBase<TArgs extends QueryArgs> = QueryBase<TArgs>;
+type index_d_QueryClientRef = QueryClientRef;
+type index_d_QueryDependencies = QueryDependencies;
+type index_d_QueryErrorResponse = QueryErrorResponse;
+type index_d_QueryErrorResponseItem = QueryErrorResponseItem;
+type index_d_QueryErrorResponseList = QueryErrorResponseList;
+type index_d_QueryErrorResponseSingle = QueryErrorResponseSingle;
+type index_d_QueryExecute<TArgs extends QueryArgs> = QueryExecute<TArgs>;
+type index_d_QueryExecuteArgs<TArgs extends QueryArgs> = QueryExecuteArgs<TArgs>;
+type index_d_QueryExecuteOptions<TArgs extends QueryArgs> = QueryExecuteOptions<TArgs>;
+type index_d_QueryExecuteState = QueryExecuteState;
+type index_d_QueryExecutionState<TArgs extends QueryArgs> = QueryExecutionState<TArgs>;
+type index_d_QueryExecutionStateFailure = QueryExecutionStateFailure;
+type index_d_QueryExecutionStateLoading<TArgs extends QueryArgs> = QueryExecutionStateLoading<TArgs>;
+type index_d_QueryExecutionStateLoadingWithCachedResponse<TArgs extends QueryArgs> = QueryExecutionStateLoadingWithCachedResponse<TArgs>;
+type index_d_QueryExecutionStateLoadingWithNoResponse = QueryExecutionStateLoadingWithNoResponse;
+type index_d_QueryExecutionStateSuccess<TArgs extends QueryArgs> = QueryExecutionStateSuccess<TArgs>;
+type index_d_QueryFeature<TArgs extends QueryArgs> = QueryFeature<TArgs>;
+type index_d_QueryFeatureContext<TArgs extends QueryArgs> = QueryFeatureContext<TArgs>;
+type index_d_QueryFeatureFlags = QueryFeatureFlags;
+type index_d_QueryFeatureFn<TArgs extends QueryArgs> = QueryFeatureFn<TArgs>;
+type index_d_QueryFeatureType = QueryFeatureType;
+declare const index_d_QueryFeatureType: typeof QueryFeatureType;
+type index_d_QueryKey = QueryKey;
+type index_d_QueryKeyNoCache = QueryKeyNoCache;
+type index_d_QueryKeyOrNone = QueryKeyOrNone;
+type index_d_QueryMethod = QueryMethod;
+type index_d_QueryParamsType<T extends QueryArgs | null> = QueryParamsType<T>;
+type index_d_QueryRepository = QueryRepository;
+type index_d_QueryRepositoryDependencies = QueryRepositoryDependencies;
+type index_d_QueryRepositoryItem<TArgs extends QueryArgs> = QueryRepositoryItem<TArgs>;
+type index_d_QueryRepositoryRequestOptions<TArgs extends QueryArgs> = QueryRepositoryRequestOptions<TArgs>;
+type index_d_QueryRuntimeErrorCode = QueryRuntimeErrorCode;
+declare const index_d_QueryRuntimeErrorCode: typeof QueryRuntimeErrorCode;
+type index_d_QuerySnapshot<TArgs extends QueryArgs> = QuerySnapshot<TArgs>;
+type index_d_QueryStack<TQuery extends AnyQuery$1, TCreator extends AnyQueryCreator$1, TTransform> = QueryStack<TQuery, TCreator, TTransform>;
+type index_d_QueryStackSubtle<TCreator extends AnyQueryCreator$1, TQuery extends AnyQuery$1> = QueryStackSubtle<TCreator, TQuery>;
+type index_d_QueryStateSubtle<TArgs extends QueryArgs> = QueryStateSubtle<TArgs>;
+type index_d_QuerySubtle<TArgs extends QueryArgs> = QuerySubtle<TArgs>;
+type index_d_ReadonlyQuery<TArgs extends QueryArgs> = ReadonlyQuery<TArgs>;
+type index_d_RequestArgs<T extends QueryArgs | null> = RequestArgs<T>;
+type index_d_ResetExecuteStateOptions<TArgs extends QueryArgs> = ResetExecuteStateOptions<TArgs>;
+type index_d_ResponseType<T extends QueryArgs | null> = ResponseType<T>;
+type index_d_RunQueryCreator<TCreator extends AnyQueryCreator$1> = RunQueryCreator<TCreator>;
+type index_d_RunQueryExecuteOptions = RunQueryExecuteOptions;
+declare const index_d_SPEED_BUFFER_TIME_IN_MS: typeof SPEED_BUFFER_TIME_IN_MS;
+type index_d_SetupQueryDependenciesOptions = SetupQueryDependenciesOptions;
+type index_d_SetupQueryStateOptions = SetupQueryStateOptions;
+type index_d_ShouldRetryRequestFn = ShouldRetryRequestFn;
+type index_d_ShouldRetryRequestOptions = ShouldRetryRequestOptions;
+type index_d_ShouldRetryRequestResult = ShouldRetryRequestResult;
+type index_d_SocketMessageView<TMessageData = unknown> = SocketMessageView<TMessageData>;
+type index_d_WebSocketClient<TMessageData extends SocketMessageView> = WebSocketClient<TMessageData>;
+type index_d_WebSocketClientConfig = WebSocketClientConfig;
+type index_d_WebSocketClientRef<TMessageData extends SocketMessageView = SocketMessageView> = WebSocketClientRef<TMessageData>;
+type index_d_WebSocketClientSubtle = WebSocketClientSubtle;
+type index_d_WebSocketRoom<TMessageData extends SocketMessageView> = WebSocketRoom<TMessageData>;
+type index_d_WithAutoRefreshFeatureOptions = WithAutoRefreshFeatureOptions;
+type index_d_WithErrorHandlingFeatureOptions = WithErrorHandlingFeatureOptions;
+type index_d_WithLegacyConfig = WithLegacyConfig;
+type index_d_WithLoggingFeatureOptions<TArgs extends QueryArgs> = WithLoggingFeatureOptions<TArgs>;
+type index_d_WithPollingFeatureOptions = WithPollingFeatureOptions;
+type index_d_WithResponseUpdateFeatureFnData<TArgs extends QueryArgs> = WithResponseUpdateFeatureFnData<TArgs>;
+type index_d_WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = WithResponseUpdateFeatureOptions<TArgs>;
+declare const index_d_applyQueryFeatures: typeof applyQueryFeatures;
+declare const index_d_bearerExpiresInPropertyNotNumber: typeof bearerExpiresInPropertyNotNumber;
+declare const index_d_circularQueryDependencyChecker: typeof circularQueryDependencyChecker;
+declare const index_d_cleanupPreviousExecute: typeof cleanupPreviousExecute;
+declare const index_d_contentfulGqlLikePaginationAdapter: typeof contentfulGqlLikePaginationAdapter;
+declare const index_d_cookieLoginTriedButCookieDisabled: typeof cookieLoginTriedButCookieDisabled;
+declare const index_d_createBearerAuthProvider: typeof createBearerAuthProvider;
+declare const index_d_createBearerAuthProviderConfig: typeof createBearerAuthProviderConfig;
+declare const index_d_createDeleteQuery: typeof createDeleteQuery;
+declare const index_d_createExecuteFn: typeof createExecuteFn;
+declare const index_d_createGetQuery: typeof createGetQuery;
+declare const index_d_createGqlExecuteFn: typeof createGqlExecuteFn;
+declare const index_d_createGqlMutationViaGet: typeof createGqlMutationViaGet;
+declare const index_d_createGqlMutationViaPost: typeof createGqlMutationViaPost;
+declare const index_d_createGqlQuery: typeof createGqlQuery;
+declare const index_d_createGqlQueryCreator: typeof createGqlQueryCreator;
+declare const index_d_createGqlQueryViaGet: typeof createGqlQueryViaGet;
+declare const index_d_createGqlQueryViaPost: typeof createGqlQueryViaPost;
+declare const index_d_createHttpRequest: typeof createHttpRequest;
+declare const index_d_createLegacyQueryCreator: typeof createLegacyQueryCreator;
+declare const index_d_createPagedQueryStack: typeof createPagedQueryStack;
+declare const index_d_createPatchQuery: typeof createPatchQuery;
+declare const index_d_createPostQuery: typeof createPostQuery;
+declare const index_d_createPutQuery: typeof createPutQuery;
+declare const index_d_createQuery: typeof createQuery;
+declare const index_d_createQueryClient: typeof createQueryClient;
+declare const index_d_createQueryClientConfig: typeof createQueryClientConfig;
+declare const index_d_createQueryCreator: typeof createQueryCreator;
+declare const index_d_createQueryErrorResponse: typeof createQueryErrorResponse;
+declare const index_d_createQueryObject: typeof createQueryObject;
+declare const index_d_createQueryRepository: typeof createQueryRepository;
+declare const index_d_createQuerySnapshotFn: typeof createQuerySnapshotFn;
+declare const index_d_createQueryStack: typeof createQueryStack;
+declare const index_d_createSecureDeleteQuery: typeof createSecureDeleteQuery;
+declare const index_d_createSecureExecuteFn: typeof createSecureExecuteFn;
+declare const index_d_createSecureGetQuery: typeof createSecureGetQuery;
+declare const index_d_createSecurePatchQuery: typeof createSecurePatchQuery;
+declare const index_d_createSecurePostQuery: typeof createSecurePostQuery;
+declare const index_d_createSecurePutQuery: typeof createSecurePutQuery;
+declare const index_d_createSecureQuery: typeof createSecureQuery;
+declare const index_d_createSecureQueryCreator: typeof createSecureQueryCreator;
+declare const index_d_createWebSocketClient: typeof createWebSocketClient;
+declare const index_d_createWebSocketClientConfig: typeof createWebSocketClientConfig;
+declare const index_d_defaultResponseTransformerResponseNotContainingAccessToken: typeof defaultResponseTransformerResponseNotContainingAccessToken;
+declare const index_d_defaultResponseTransformerResponseNotContainingRefreshToken: typeof defaultResponseTransformerResponseNotContainingRefreshToken;
+declare const index_d_defaultResponseTransformerResponseNotObject: typeof defaultResponseTransformerResponseNotObject;
+declare const index_d_disableCookieCalledWithoutCookieConfig: typeof disableCookieCalledWithoutCookieConfig;
+declare const index_d_dynLikePaginationAdapter: typeof dynLikePaginationAdapter;
+declare const index_d_enableCookieCalledWithoutCookieConfig: typeof enableCookieCalledWithoutCookieConfig;
+declare const index_d_ethletePaginationAdapter: typeof ethletePaginationAdapter;
+declare const index_d_extractExpiresInSeconds: typeof extractExpiresInSeconds;
+declare const index_d_fakePaginationAdapter: typeof fakePaginationAdapter;
+declare const index_d_getQueryFeatureUsage: typeof getQueryFeatureUsage;
+declare const index_d_ggLikePaginationAdapter: typeof ggLikePaginationAdapter;
+declare const index_d_isCreateGqlQueryOptions: typeof isCreateGqlQueryOptions;
+declare const index_d_isLegacyQuery: typeof isLegacyQuery;
+declare const index_d_loginCalledWithoutConfig: typeof loginCalledWithoutConfig;
+declare const index_d_loginWithTokenCalledWithoutConfig: typeof loginWithTokenCalledWithoutConfig;
+declare const index_d_maybeExecute: typeof maybeExecute;
+declare const index_d_nestedEffect: typeof nestedEffect;
+declare const index_d_normalizeQueryRepositoryKey: typeof normalizeQueryRepositoryKey;
+declare const index_d_pagedQueryStackNextPageCalledWithoutPreviousPage: typeof pagedQueryStackNextPageCalledWithoutPreviousPage;
+declare const index_d_pagedQueryStackPageBiggerThanTotalPages: typeof pagedQueryStackPageBiggerThanTotalPages;
+declare const index_d_pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: typeof pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage;
+declare const index_d_parseHttpErrorCodeToMessageDe: typeof parseHttpErrorCodeToMessageDe;
+declare const index_d_parseHttpErrorCodeToMessageEn: typeof parseHttpErrorCodeToMessageEn;
+declare const index_d_parseHttpErrorCodeToTitleDe: typeof parseHttpErrorCodeToTitleDe;
+declare const index_d_parseHttpErrorCodeToTitleEn: typeof parseHttpErrorCodeToTitleEn;
+declare const index_d_provideBearerAuthProvider: typeof provideBearerAuthProvider;
+declare const index_d_provideQueryClient: typeof provideQueryClient;
+declare const index_d_provideWebSocketClient: typeof provideWebSocketClient;
+declare const index_d_queryExecute: typeof queryExecute;
+declare const index_d_queryFeatureUsedMultipleTimes: typeof queryFeatureUsedMultipleTimes;
+declare const index_d_queryStackTotalQueriesAndExpectedQueriesMismatch: typeof queryStackTotalQueriesAndExpectedQueriesMismatch;
+declare const index_d_queryStackWithArgsUsed: typeof queryStackWithArgsUsed;
+declare const index_d_queryStackWithResponseUpdateUsed: typeof queryStackWithResponseUpdateUsed;
+declare const index_d_refreshTokenCalledWithoutConfig: typeof refreshTokenCalledWithoutConfig;
+declare const index_d_resetExecuteState: typeof resetExecuteState;
+declare const index_d_selectRoleCalledWithoutConfig: typeof selectRoleCalledWithoutConfig;
+declare const index_d_setupQueryDependencies: typeof setupQueryDependencies;
+declare const index_d_setupQueryExecuteState: typeof setupQueryExecuteState;
+declare const index_d_setupQueryState: typeof setupQueryState;
+declare const index_d_shouldAutoExecuteGqlQuery: typeof shouldAutoExecuteGqlQuery;
+declare const index_d_shouldAutoExecuteQuery: typeof shouldAutoExecuteQuery;
+declare const index_d_shouldRetryRequest: typeof shouldRetryRequest;
+declare const index_d_silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent: typeof silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent;
+declare const index_d_splitQueryConfig: typeof splitQueryConfig;
+declare const index_d_transformArrayResponse: typeof transformArrayResponse;
+declare const index_d_transformPaginatedResponse: typeof transformPaginatedResponse;
+declare const index_d_unableToDecryptBearerToken: typeof unableToDecryptBearerToken;
+declare const index_d_uncacheableRequestHasAllowCacheParam: typeof uncacheableRequestHasAllowCacheParam;
+declare const index_d_uncacheableRequestHasCacheKeyParam: typeof uncacheableRequestHasCacheKeyParam;
+declare const index_d_withArgs: typeof withArgs;
+declare const index_d_withArgsQueryFeatureMissingButRouteIsFunction: typeof withArgsQueryFeatureMissingButRouteIsFunction;
+declare const index_d_withAutoRefresh: typeof withAutoRefresh;
+declare const index_d_withAutoRefreshUsedInManualQuery: typeof withAutoRefreshUsedInManualQuery;
+declare const index_d_withAutoRefreshUsedOnUnsupportedHttpMethod: typeof withAutoRefreshUsedOnUnsupportedHttpMethod;
+declare const index_d_withErrorHandling: typeof withErrorHandling;
+declare const index_d_withLogging: typeof withLogging;
+declare const index_d_withPolling: typeof withPolling;
+declare const index_d_withPollingUsedOnUnsupportedHttpMethod: typeof withPollingUsedOnUnsupportedHttpMethod;
+declare const index_d_withResponseUpdate: typeof withResponseUpdate;
+declare const index_d_withSuccessHandling: typeof withSuccessHandling;
+declare namespace index_d {
+  export { index_d_CLEAR_QUERY_ARGS as CLEAR_QUERY_ARGS, index_d_LegacyQuery as LegacyQuery, index_d_LegacyQueryCreator as LegacyQueryCreator, index_d_ParseHttpErrorCodeToMessageDePipe as ParseHttpErrorCodeToMessageDePipe, index_d_ParseHttpErrorCodeToMessageEnPipe as ParseHttpErrorCodeToMessageEnPipe, index_d_ParseHttpErrorCodeToTitleDePipe as ParseHttpErrorCodeToTitleDePipe, index_d_ParseHttpErrorCodeToTitleEnPipe as ParseHttpErrorCodeToTitleEnPipe, index_d_QueryFeatureType as QueryFeatureType, index_d_QueryRuntimeErrorCode as QueryRuntimeErrorCode, index_d_SPEED_BUFFER_TIME_IN_MS as SPEED_BUFFER_TIME_IN_MS, index_d_applyQueryFeatures as applyQueryFeatures, index_d_bearerExpiresInPropertyNotNumber as bearerExpiresInPropertyNotNumber, buildQueryCacheKey$1 as buildQueryCacheKey, index_d_circularQueryDependencyChecker as circularQueryDependencyChecker, index_d_cleanupPreviousExecute as cleanupPreviousExecute, index_d_contentfulGqlLikePaginationAdapter as contentfulGqlLikePaginationAdapter, index_d_cookieLoginTriedButCookieDisabled as cookieLoginTriedButCookieDisabled, index_d_createBearerAuthProvider as createBearerAuthProvider, index_d_createBearerAuthProviderConfig as createBearerAuthProviderConfig, index_d_createDeleteQuery as createDeleteQuery, index_d_createExecuteFn as createExecuteFn, index_d_createGetQuery as createGetQuery, index_d_createGqlExecuteFn as createGqlExecuteFn, index_d_createGqlMutationViaGet as createGqlMutationViaGet, index_d_createGqlMutationViaPost as createGqlMutationViaPost, index_d_createGqlQuery as createGqlQuery, index_d_createGqlQueryCreator as createGqlQueryCreator, index_d_createGqlQueryViaGet as createGqlQueryViaGet, index_d_createGqlQueryViaPost as createGqlQueryViaPost, index_d_createHttpRequest as createHttpRequest, index_d_createLegacyQueryCreator as createLegacyQueryCreator, index_d_createPagedQueryStack as createPagedQueryStack, index_d_createPatchQuery as createPatchQuery, index_d_createPostQuery as createPostQuery, index_d_createPutQuery as createPutQuery, index_d_createQuery as createQuery, index_d_createQueryClient as createQueryClient, index_d_createQueryClientConfig as createQueryClientConfig, index_d_createQueryCreator as createQueryCreator, index_d_createQueryErrorResponse as createQueryErrorResponse, index_d_createQueryObject as createQueryObject, index_d_createQueryRepository as createQueryRepository, index_d_createQuerySnapshotFn as createQuerySnapshotFn, index_d_createQueryStack as createQueryStack, index_d_createSecureDeleteQuery as createSecureDeleteQuery, index_d_createSecureExecuteFn as createSecureExecuteFn, index_d_createSecureGetQuery as createSecureGetQuery, index_d_createSecurePatchQuery as createSecurePatchQuery, index_d_createSecurePostQuery as createSecurePostQuery, index_d_createSecurePutQuery as createSecurePutQuery, index_d_createSecureQuery as createSecureQuery, index_d_createSecureQueryCreator as createSecureQueryCreator, index_d_createWebSocketClient as createWebSocketClient, index_d_createWebSocketClientConfig as createWebSocketClientConfig, index_d_defaultResponseTransformerResponseNotContainingAccessToken as defaultResponseTransformerResponseNotContainingAccessToken, index_d_defaultResponseTransformerResponseNotContainingRefreshToken as defaultResponseTransformerResponseNotContainingRefreshToken, index_d_defaultResponseTransformerResponseNotObject as defaultResponseTransformerResponseNotObject, index_d_disableCookieCalledWithoutCookieConfig as disableCookieCalledWithoutCookieConfig, index_d_dynLikePaginationAdapter as dynLikePaginationAdapter, index_d_enableCookieCalledWithoutCookieConfig as enableCookieCalledWithoutCookieConfig, index_d_ethletePaginationAdapter as ethletePaginationAdapter, index_d_extractExpiresInSeconds as extractExpiresInSeconds, index_d_fakePaginationAdapter as fakePaginationAdapter, index_d_getQueryFeatureUsage as getQueryFeatureUsage, index_d_ggLikePaginationAdapter as ggLikePaginationAdapter, index_d_isCreateGqlQueryOptions as isCreateGqlQueryOptions, index_d_isLegacyQuery as isLegacyQuery, index_d_loginCalledWithoutConfig as loginCalledWithoutConfig, index_d_loginWithTokenCalledWithoutConfig as loginWithTokenCalledWithoutConfig, index_d_maybeExecute as maybeExecute, index_d_nestedEffect as nestedEffect, index_d_normalizeQueryRepositoryKey as normalizeQueryRepositoryKey, index_d_pagedQueryStackNextPageCalledWithoutPreviousPage as pagedQueryStackNextPageCalledWithoutPreviousPage, index_d_pagedQueryStackPageBiggerThanTotalPages as pagedQueryStackPageBiggerThanTotalPages, index_d_pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage as pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, index_d_parseHttpErrorCodeToMessageDe as parseHttpErrorCodeToMessageDe, index_d_parseHttpErrorCodeToMessageEn as parseHttpErrorCodeToMessageEn, index_d_parseHttpErrorCodeToTitleDe as parseHttpErrorCodeToTitleDe, index_d_parseHttpErrorCodeToTitleEn as parseHttpErrorCodeToTitleEn, index_d_provideBearerAuthProvider as provideBearerAuthProvider, index_d_provideQueryClient as provideQueryClient, index_d_provideWebSocketClient as provideWebSocketClient, index_d_queryExecute as queryExecute, index_d_queryFeatureUsedMultipleTimes as queryFeatureUsedMultipleTimes, index_d_queryStackTotalQueriesAndExpectedQueriesMismatch as queryStackTotalQueriesAndExpectedQueriesMismatch, index_d_queryStackWithArgsUsed as queryStackWithArgsUsed, index_d_queryStackWithResponseUpdateUsed as queryStackWithResponseUpdateUsed, index_d_refreshTokenCalledWithoutConfig as refreshTokenCalledWithoutConfig, index_d_resetExecuteState as resetExecuteState, index_d_selectRoleCalledWithoutConfig as selectRoleCalledWithoutConfig, index_d_setupQueryDependencies as setupQueryDependencies, index_d_setupQueryExecuteState as setupQueryExecuteState, index_d_setupQueryState as setupQueryState, index_d_shouldAutoExecuteGqlQuery as shouldAutoExecuteGqlQuery, index_d_shouldAutoExecuteQuery as shouldAutoExecuteQuery, shouldCacheQuery$1 as shouldCacheQuery, index_d_shouldRetryRequest as shouldRetryRequest, index_d_silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent as silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, index_d_splitQueryConfig as splitQueryConfig, index_d_transformArrayResponse as transformArrayResponse, index_d_transformPaginatedResponse as transformPaginatedResponse, index_d_unableToDecryptBearerToken as unableToDecryptBearerToken, index_d_uncacheableRequestHasAllowCacheParam as uncacheableRequestHasAllowCacheParam, index_d_uncacheableRequestHasCacheKeyParam as uncacheableRequestHasCacheKeyParam, index_d_withArgs as withArgs, index_d_withArgsQueryFeatureMissingButRouteIsFunction as withArgsQueryFeatureMissingButRouteIsFunction, index_d_withAutoRefresh as withAutoRefresh, index_d_withAutoRefreshUsedInManualQuery as withAutoRefreshUsedInManualQuery, index_d_withAutoRefreshUsedOnUnsupportedHttpMethod as withAutoRefreshUsedOnUnsupportedHttpMethod, index_d_withErrorHandling as withErrorHandling, index_d_withLogging as withLogging, index_d_withPolling as withPolling, index_d_withPollingUsedOnUnsupportedHttpMethod as withPollingUsedOnUnsupportedHttpMethod, index_d_withResponseUpdate as withResponseUpdate, index_d_withSuccessHandling as withSuccessHandling };
+  export type { index_d_AnyBearerAuthProviderConfig as AnyBearerAuthProviderConfig, index_d_AnyLegacyQuery as AnyLegacyQuery, index_d_AnyLegacyQueryCreator as AnyLegacyQueryCreator, index_d_AnyPagedQueryStack as AnyPagedQueryStack, AnyQuery$1 as AnyQuery, AnyQueryCreator$1 as AnyQueryCreator, index_d_AnyQuerySnapshot as AnyQuerySnapshot, index_d_AnyQueryStack as AnyQueryStack, BearerAuthProvider$1 as BearerAuthProvider, index_d_BearerAuthProviderConfig as BearerAuthProviderConfig, index_d_BearerAuthProviderCookieConfig as BearerAuthProviderCookieConfig, index_d_BearerAuthProviderRef as BearerAuthProviderRef, index_d_BearerAuthProviderRouteConfig as BearerAuthProviderRouteConfig, index_d_BearerAuthProviderTokens as BearerAuthProviderTokens, index_d_BodyType as BodyType, index_d_CacheAdapterFn as CacheAdapterFn, index_d_CleanupPreviousExecuteOptions as CleanupPreviousExecuteOptions, index_d_ClearQueryArgs as ClearQueryArgs, index_d_CreateBearerAuthProviderConfigOptions as CreateBearerAuthProviderConfigOptions, index_d_CreateGqlQueryCreatorOptions as CreateGqlQueryCreatorOptions, index_d_CreateGqlQueryExecuteOptions as CreateGqlQueryExecuteOptions, index_d_CreateGqlQueryOptions as CreateGqlQueryOptions, index_d_CreateHttpRequestClientOptions as CreateHttpRequestClientOptions, index_d_CreateHttpRequestDependencies as CreateHttpRequestDependencies, index_d_CreateHttpRequestOptions as CreateHttpRequestOptions, index_d_CreateLegacyQueryCreatorOptions as CreateLegacyQueryCreatorOptions, index_d_CreateLegacyQueryOptions as CreateLegacyQueryOptions, index_d_CreatePagedQueryStackOptions as CreatePagedQueryStackOptions, index_d_CreateQueryClientConfigOptions as CreateQueryClientConfigOptions, index_d_CreateQueryCreatorOptions as CreateQueryCreatorOptions, index_d_CreateQueryExecuteOptions as CreateQueryExecuteOptions, index_d_CreateQueryObjectOptions as CreateQueryObjectOptions, index_d_CreateQueryOptions as CreateQueryOptions, index_d_CreateQueryRepositoryConfig as CreateQueryRepositoryConfig, index_d_CreateQuerySnapshotOptions as CreateQuerySnapshotOptions, index_d_CreateQueryStackOptions as CreateQueryStackOptions, index_d_CreateSecureQueryExecuteOptions as CreateSecureQueryExecuteOptions, index_d_CreateSecureQueryOptions as CreateSecureQueryOptions, index_d_CreateWebSocketClientConfig as CreateWebSocketClientConfig, index_d_CreateWebSocketClientTransport as CreateWebSocketClientTransport, index_d_GqlQueryArgs as GqlQueryArgs, index_d_GqlQueryMethod as GqlQueryMethod, index_d_GqlQueryTransport as GqlQueryTransport, index_d_GqlVariablesType as GqlVariablesType, index_d_HttpErrorEvent as HttpErrorEvent, index_d_HttpRequest as HttpRequest, index_d_HttpRequestLoadingProgressState as HttpRequestLoadingProgressState, index_d_HttpRequestLoadingState as HttpRequestLoadingState, index_d_HttpRequestResponseType as HttpRequestResponseType, index_d_HttpRequestTransferCacheConfig as HttpRequestTransferCacheConfig, index_d_InternalCreateGqlQueryCreatorOptions as InternalCreateGqlQueryCreatorOptions, index_d_InternalCreateQueryCreatorOptions as InternalCreateQueryCreatorOptions, index_d_InternalQueryExecute as InternalQueryExecute, index_d_InternalRunQueryExecuteOptions as InternalRunQueryExecuteOptions, index_d_InternalSecureCreateQueryCreatorOptions as InternalSecureCreateQueryCreatorOptions, index_d_InternalWebSocketRoom as InternalWebSocketRoom, index_d_LegacyArgumentsOfQueryArgs as LegacyArgumentsOfQueryArgs, index_d_LegacyQueryPrepareFn as LegacyQueryPrepareFn, index_d_PagedQueryStack as PagedQueryStack, index_d_PagedQueryStackDirection as PagedQueryStackDirection, index_d_PagedQueryStackExecuteOptions as PagedQueryStackExecuteOptions, index_d_PagedQueryStackResetOptions as PagedQueryStackResetOptions, index_d_PathParamsType as PathParamsType, Query$1 as Query, index_d_QueryArgs as QueryArgs, QueryArgsOf$1 as QueryArgsOf, index_d_QueryArgsOfLegacyArguments as QueryArgsOfLegacyArguments, index_d_QueryBase as QueryBase, QueryClient$1 as QueryClient, QueryClientConfig$1 as QueryClientConfig, index_d_QueryClientRef as QueryClientRef, QueryConfig$1 as QueryConfig, QueryCreator$1 as QueryCreator, index_d_QueryDependencies as QueryDependencies, index_d_QueryErrorResponse as QueryErrorResponse, index_d_QueryErrorResponseItem as QueryErrorResponseItem, index_d_QueryErrorResponseList as QueryErrorResponseList, index_d_QueryErrorResponseSingle as QueryErrorResponseSingle, index_d_QueryExecute as QueryExecute, index_d_QueryExecuteArgs as QueryExecuteArgs, index_d_QueryExecuteOptions as QueryExecuteOptions, index_d_QueryExecuteState as QueryExecuteState, index_d_QueryExecutionState as QueryExecutionState, index_d_QueryExecutionStateFailure as QueryExecutionStateFailure, index_d_QueryExecutionStateLoading as QueryExecutionStateLoading, index_d_QueryExecutionStateLoadingWithCachedResponse as QueryExecutionStateLoadingWithCachedResponse, index_d_QueryExecutionStateLoadingWithNoResponse as QueryExecutionStateLoadingWithNoResponse, index_d_QueryExecutionStateSuccess as QueryExecutionStateSuccess, index_d_QueryFeature as QueryFeature, index_d_QueryFeatureContext as QueryFeatureContext, index_d_QueryFeatureFlags as QueryFeatureFlags, index_d_QueryFeatureFn as QueryFeatureFn, index_d_QueryKey as QueryKey, index_d_QueryKeyNoCache as QueryKeyNoCache, index_d_QueryKeyOrNone as QueryKeyOrNone, index_d_QueryMethod as QueryMethod, index_d_QueryParamsType as QueryParamsType, index_d_QueryRepository as QueryRepository, index_d_QueryRepositoryDependencies as QueryRepositoryDependencies, index_d_QueryRepositoryItem as QueryRepositoryItem, index_d_QueryRepositoryRequestOptions as QueryRepositoryRequestOptions, index_d_QuerySnapshot as QuerySnapshot, index_d_QueryStack as QueryStack, index_d_QueryStackSubtle as QueryStackSubtle, QueryState$1 as QueryState, index_d_QueryStateSubtle as QueryStateSubtle, index_d_QuerySubtle as QuerySubtle, index_d_ReadonlyQuery as ReadonlyQuery, index_d_RequestArgs as RequestArgs, index_d_ResetExecuteStateOptions as ResetExecuteStateOptions, index_d_ResponseType as ResponseType, RouteString$1 as RouteString, RouteType$1 as RouteType, index_d_RunQueryCreator as RunQueryCreator, index_d_RunQueryExecuteOptions as RunQueryExecuteOptions, index_d_SetupQueryDependenciesOptions as SetupQueryDependenciesOptions, index_d_SetupQueryStateOptions as SetupQueryStateOptions, index_d_ShouldRetryRequestFn as ShouldRetryRequestFn, index_d_ShouldRetryRequestOptions as ShouldRetryRequestOptions, index_d_ShouldRetryRequestResult as ShouldRetryRequestResult, index_d_SocketMessageView as SocketMessageView, index_d_WebSocketClient as WebSocketClient, index_d_WebSocketClientConfig as WebSocketClientConfig, index_d_WebSocketClientRef as WebSocketClientRef, index_d_WebSocketClientSubtle as WebSocketClientSubtle, index_d_WebSocketRoom as WebSocketRoom, index_d_WithAutoRefreshFeatureOptions as WithAutoRefreshFeatureOptions, index_d_WithErrorHandlingFeatureOptions as WithErrorHandlingFeatureOptions, index_d_WithLegacyConfig as WithLegacyConfig, index_d_WithLoggingFeatureOptions as WithLoggingFeatureOptions, index_d_WithPollingFeatureOptions as WithPollingFeatureOptions, index_d_WithResponseUpdateFeatureFnData as WithResponseUpdateFeatureFnData, index_d_WithResponseUpdateFeatureOptions as WithResponseUpdateFeatureOptions };
+}
+
+interface QueryFieldOptions<T = unknown> {
+    /**
+     * The default value of the field.
+     * Will be set to the initial value of the form control if not specified.
+     * If a function is provided, it will be called to get the default value.
+     */
+    defaultValue?: T | (() => T) | null;
+    /**
+     * Debounce time in milliseconds.
+     */
+    debounce?: number;
+    /**
+     *  Whether the debounce should not be applied if the value is falsy.
+     *  This is useful for fields that can be cleared like a search field.
+     *
+     *  @default false
+     */
+    disableDebounceIfFalsy?: boolean;
+    /**
+     * The form control for the field.
+     */
+    control: FormControl<T | null>;
+    /**
+     * Append the field's value to the url.
+     *
+     * The field wont be appended to the url if one of the following is true:
+     * - It is the default value and `appendDefaultValueToUrl` is `false`
+     * - It is an empty string
+     * - It is `null`
+     * - It is `undefined`
+     *
+     * @default true
+     */
+    appendToUrl?: boolean;
+    /**
+     * Append the field's value to the url even if it is the default value.
+     * Will be ignored if `appendToUrl` is `false`.
+     *
+     * @default false
+     */
+    appendDefaultValueToUrl?: boolean;
+    /**
+     * Reset the field's value to the default value if one or more of the specified fields are changed.
+     *
+     * @example
+     * // Given this field is a `page` field, the field will be reset if the `limit`, `query` or `search` fields are changed.
+     * ['limit', 'query', 'search']
+     */
+    isResetBy?: string | string[];
+    /**
+     * Whether the field should change the count of current active filters.
+     *
+     * Will be `true` for these common fields:
+     * - `page`
+     * - `skip`
+     * - `take`
+     * - `limit`
+     * - `sort`
+     * - `sortBy`
+     * - `sortOrder`
+     * - `query`
+     * - `search`
+     * @default false
+     */
+    skipInFilterCount?: boolean;
+    /**
+     * By default, the field's string value is transformed to it's matching primitive type.
+     * Meaning that a string `'true'` will be transformed to a boolean `true` and a string `'5'` will be transformed to a number `5`.
+     * If this is set to `true`, the field's value will not be transformed.
+     *
+     * @default false
+     */
+    skipAutoTransform?: boolean;
+    /**
+     * A function that transforms the the value gotten from the url query params to a value required by the field.
+     * E.g. for a number field, the value from the url query params is a string, but the field requires a number.
+     *
+     * The following common transformations are already implemented:
+     * - `transformToString`
+     * - `transformToStringArray`
+     * - `transformToNumber`
+     * - `transformToNumberArray`
+     * - `transformToBoolean`
+     * - `transformToBooleanArray`
+     * - `transformToDate` (expects a string in the default js format)
+     * - `transformToDateArray` (expects strings in the default js format)
+     * - `transformToSort` (expects a string in the format `field:direction`)
+     */
+    queryParamToValueTransformFn?: (val: unknown) => T | null;
+    /**
+     * A function that transforms the value of the field to a value that can be appended to the url query params.
+     *
+     * The following common transformations are already implemented:
+     * - `transformToSortQueryParam` (returns an object containing `field` and `direction` properties)
+     */
+    valueToQueryParamTransformFn?: (val: T | null) => unknown;
+}
+type OptionalQueryFieldOptions<T = string> = Partial<QueryFieldOptions<T>>;
+type QueryFormGroupControls<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control'];
+};
+type QueryFormValue<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control']['value'];
+};
+type QueryFormOf<T extends FormGroup> = {
+    [K in keyof T['controls']]: QueryField<T['controls'][K]['value']>;
+};
+interface QueryFormGroup extends FormGroup {
+    _setValue: FormGroup['setValue'];
+    _patchValue: FormGroup['patchValue'];
+    setValue(value: unknown, options?: QueryFormWriteOptions): void;
+    patchValue(value: unknown, options?: QueryFormWriteOptions): void;
+}
+interface QueryFormObserveOptions {
+    /**
+     * Whether the form value should be synced to the url query params.
+     * @default true
+     */
+    writeToQueryParams?: boolean;
+    /**
+     * Whether the form value should be updated when the url query params change.
+     * @default true
+     */
+    syncOnNavigation?: boolean;
+    /**
+     * If true, the navigation will not create a new entry in the browser's history.
+     * @default false
+     */
+    replaceUrl?: boolean;
+}
+interface QueryFormValueEvent<T extends Record<string, QueryField<any>>> {
+    previousValue: QueryFormValue<T> | null;
+    currentValue: QueryFormValue<T>;
+}
+interface QueryFormWriteOptions {
+    /**
+     * When true, each change only affects this control, and not its parent.
+     * @default false
+     */
+    onlySelf?: boolean;
+    /**
+     * When true or not supplied (the default), both the `statusChanges` and `valueChanges`
+     * observables emit events with the latest status and value when the control value is updated.
+     * When false, no events are emitted.
+     * @default true
+     */
+    emitEvent?: boolean;
+    /**
+     * When true, the `resetBy` conditions will be ignored for this write.
+     * @default false
+     */
+    skipResets?: boolean;
+}
+
+declare const transformToString: (value: unknown) => string | null;
+declare const transformToStringArray: (value: unknown) => string[] | null;
+declare const transformToNumber: (value: unknown) => number | null;
+declare const transformToNumberArray: (value: unknown) => number[] | null;
+declare const transformToBoolean: (value: unknown) => boolean | null;
+declare const transformToBooleanArray: (value: unknown) => boolean[] | null;
+declare const transformToDate: (value: unknown) => Date | null;
+declare const transformToDateArray: (value: unknown) => Date[] | null;
+type SortDirection = 'asc' | 'desc' | '';
+interface Sort {
+    active: string;
+    direction: SortDirection;
+}
+declare const transformToSort: (value: unknown) => Sort | null;
+declare const transformToSortQueryParam: (value: unknown) => string | null;
+
+declare class QueryField<T> {
+    data: QueryFieldOptions<T>;
+    get control(): FormControl<T | null>;
+    constructor(data: QueryFieldOptions<T>);
+}
+declare class SearchQueryField {
+    _data?: OptionalQueryFieldOptions<string | null> | undefined;
+    get control(): FormControl<string | null>;
+    data: QueryFieldOptions<string | null>;
+    constructor(_data?: OptionalQueryFieldOptions<string | null> | undefined);
+}
+declare class SortQueryField {
+    _data?: OptionalQueryFieldOptions<Sort | null> | undefined;
+    get control(): FormControl<Sort | null>;
+    data: QueryFieldOptions<Sort | null>;
+    constructor(_data?: OptionalQueryFieldOptions<Sort | null> | undefined);
+}
+declare class StringArrayQueryField<T extends string[]> {
+    _data?: OptionalQueryFieldOptions<T | null> | undefined;
+    get control(): FormControl<T | null>;
+    data: QueryFieldOptions<T | null>;
+    constructor(_data?: OptionalQueryFieldOptions<T | null> | undefined);
+}
+declare class BooleanArrayQueryField {
+    _data?: OptionalQueryFieldOptions<boolean[] | null> | undefined;
+    get control(): FormControl<boolean[] | null>;
+    data: QueryFieldOptions<boolean[] | null>;
+    constructor(_data?: OptionalQueryFieldOptions<boolean[] | null> | undefined);
+}
+declare class NumberArrayQueryField {
+    _data?: OptionalQueryFieldOptions<number[] | null> | undefined;
+    get control(): FormControl<number[] | null>;
+    data: QueryFieldOptions<number[] | null>;
+    constructor(_data?: OptionalQueryFieldOptions<number[] | null> | undefined);
+}
+declare class DateQueryField {
+    _data?: OptionalQueryFieldOptions<Date | null> | undefined;
+    get control(): FormControl<Date | null>;
+    data: QueryFieldOptions<Date | null>;
+    constructor(_data?: OptionalQueryFieldOptions<Date | null> | undefined);
+}
+declare class DateArrayQueryField {
+    _data?: OptionalQueryFieldOptions<Date[] | null> | undefined;
+    get control(): FormControl<Date[] | null>;
+    data: QueryFieldOptions<Date[] | null>;
+    constructor(_data?: OptionalQueryFieldOptions<Date[] | null> | undefined);
+}
+interface QueryFormOptions {
+    /**
+     * A prefix to use for the query parameters. This is useful when you have multiple query forms on the same page.
+     */
+    queryParamPrefix?: string | (() => string);
+}
+type AnyQueryForm = QueryForm<any>;
+declare class QueryForm<T extends Record<string, QueryField<any>>> {
+    private _fields;
+    private _options?;
+    private readonly _destroy$;
+    private readonly _unobserveTrigger$;
+    private readonly _router;
+    private readonly _activatedRoute;
+    private readonly _defaultValues;
+    private readonly _zone;
+    private readonly _didValueChanges$;
+    private _isObserving;
+    private _skipNextResets;
+    private _queryParamChanges$;
+    private _queryParams;
+    /**
+     * The angular form group that contains all the fields.
+     *
+     * **Do not** use any of the following methods on this form group:
+     * - `setValue`: Use `QueryForm.setValue` instead.
+     * - `patchValue`: Use `QueryForm.patchValue` instead.
+     * - `valueChanges`: Use `QueryForm.changes$` instead.
+     * - `value`: Use `QueryForm.value` instead.
+     * - `controls`: Use `QueryForm.controls` instead.
+     */
+    readonly form: FormGroup<QueryFormGroupControls<T>>;
+    private readonly _lastFormValue$;
+    private readonly _currentFormValue$;
+    private get _formValue();
+    private get _form();
+    private readonly _changes$;
+    readonly changes$: rxjs.Observable<QueryFormValueEvent<T>>;
+    readonly currentValue$: rxjs.Observable<QueryFormValue<T>>;
+    readonly previousValue$: rxjs.Observable<QueryFormValue<T> | null>;
+    readonly changes: _angular_core.Signal<QueryFormValueEvent<T> | undefined>;
+    readonly currentValue: _angular_core.Signal<QueryFormValue<T> | undefined>;
+    readonly previousValue: _angular_core.Signal<QueryFormValue<T> | null | undefined>;
+    /**
+     * The number of active filters.
+     *
+     * Excludes the following fields by default:
+     * - `page`
+     * - `skip`
+     * - `take`
+     * - `limit`
+     * - `sort`
+     * - `sortBy`
+     * - `sortOrder`
+     * - `query`
+     * - `search`
+     */
+    readonly activeFilterCount$: rxjs.Observable<number>;
+    get controls(): 0 extends 1 & QueryFormGroupControls<T> ? {
+        [key: string]: _angular_forms.AbstractControl<any, any>;
+    } : QueryFormGroupControls<T>;
+    get value(): QueryFormValue<T>;
+    get defaultFormValue(): QueryFormValue<T>;
+    constructor(_fields: T, _options?: QueryFormOptions | undefined);
+    observe(options?: QueryFormObserveOptions): this;
+    private _handleQueryFormResets;
+    unobserve(): void;
+    setFormValueFromUrlQueryParams(options: {
+        queryParams: Record<string, unknown>;
+    }): boolean;
+    setValue(value: QueryFormValue<T>, options?: QueryFormWriteOptions): void;
+    patchValue(value: Partial<QueryFormValue<T>>, options?: QueryFormWriteOptions): void;
+    resetFieldToDefault(key: keyof QueryFormValue<T>, options?: QueryFormWriteOptions): void;
+    resetFieldsToDefault(keys: (keyof QueryFormValue<T>)[], options?: QueryFormWriteOptions): void;
+    resetAllFieldsToDefault(options?: QueryFormWriteOptions & {
+        skipFields?: (keyof QueryFormValue<T>)[];
+    }): void;
+    private _getDefaultValue;
+    private _transformKeyToQueryParam;
+    private _isDefaultValue;
+    private _setupFormGroup;
+    private _extractDefaultValues;
+    private _syncViaUrlQueryParams;
+    private _handleFormChange;
+    private _cleanup;
+}
+
+interface QueryAutoRefreshConfig {
+    /**
+     * Refresh the query when the query client's headers change.
+     * @default true
+     */
+    queryClientDefaultHeadersChange?: boolean;
+    /**
+     * Refresh the query when the window regains focus.
+     *
+     * This can only be disabled if `autoRefreshQueriesOnWindowFocus` is enabled on the query client.
+     * @default true
+     */
+    windowFocus?: boolean;
+}
+interface EntitySetParams<Store, Response, Arguments, Id> {
+    /**
+     * The response data.
+     */
+    response: Response;
+    /**
+     * The id(s) returned by the `id` function.
+     */
+    id: Id;
+    /**
+     * The arguments passed to the query.
+     */
+    args: Arguments;
+    /**
+     * The entity store.
+     */
+    store: Store;
+}
+interface EntityGetParams<Store, Response, Arguments, Id> {
+    /**
+     * The response data.
+     */
+    response: Response;
+    /**
+     * The id(s) returned by the `id` function.
+     */
+    id: Id;
+    /**
+     * The arguments passed to the query.
+     */
+    args: Arguments;
+    /**
+     * The entity store.
+     */
+    store: Store;
+}
+interface EntityIdParams<Response, Arguments> {
+    /**
+     * The response data.
+     */
+    response: Response;
+    /**
+     * The arguments passed to the query.
+     */
+    args: Arguments;
+}
+interface QueryEntityConfig<Store, Data, Response, Arguments, Id> {
+    /**
+     * The entity store to use for the query.
+     */
+    store: Store;
+    /**
+     * A function that returns the id of the entity. Can also return an array of ids.
+     */
+    id: (data: EntityIdParams<Response, Arguments>) => Id;
+    /**
+     * A function that returns the response data (can be a subset of the response).
+     */
+    get?: (data: EntityGetParams<Store, Response, Arguments, Id>) => Observable<Data>;
+    /**
+     * A function to update the entity store every time a new response is received.
+     */
+    set?: (data: EntitySetParams<Store, Response, Arguments, Id>) => void;
+}
+type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = {
+    /**
+     * The http method to use for the query.
+     */
+    method: Method;
+    /**
+     * Determines if the auth provider should be used for this query.
+     * The query **will throw** if the query client's auth provider is unset.
+     */
+    secure?: boolean;
+    /**
+     * Determines if the query should emit progress events.
+     */
+    reportProgress?: boolean;
+    /**
+     * Determines the query's response type.
+     * @default 'json'
+     */
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    /**
+     * Whether this request should be sent with outgoing credentials (cookies).
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * Configuration for handling auto refresh triggers.
+     *
+     * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)
+     */
+    autoRefreshOn?: QueryAutoRefreshConfig;
+    /**
+     * Whether to automatically stop polling for this query when the window loses focus.
+     * Polling will resume when the window regains focus.
+     *
+     * This can only be disabled if `enableSmartPolling` is enabled on the query client.
+     * @default true
+     */
+    enableSmartPolling?: boolean;
+    /**
+     * Object containing the query's type information.
+     */
+    types?: {
+        /**
+         * The type of the successful response.
+         */
+        response?: Response;
+        /**
+         * Arguments for executing the query.
+         *
+         * - `pathParams`: The path parameters for the query. (in front of the ? in the url)
+         * - `queryParams`: The query parameters for the query. (after the ? in the url)
+         * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
+         * - `headers`: The headers for the query.
+         * - `variables`: The variables for the query. (graphql only)
+         */
+        args?: Arguments;
+    };
+    /**
+     * Object containing the query's entity store information.
+     */
+    entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id>;
+};
+type RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = QueryConfigBase<Response, Arguments, Store, Data, Id> & {
+    /**
+     * The api route to use for the query.
+     */
+    route: Route;
+};
+type GqlTransferOption = 'GET' | 'POST';
+interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> extends QueryConfigBase<Response, Arguments, Store, Data, Id> {
+    /**
+     * The graphql query to use for the query.
+     */
+    query: string;
+    /**
+     * Determines if the query should be sent via GET or POST.
+     * - `GET`: The query will be sent via query parameters.
+     * - `POST`: The query will be sent via the body.
+     * @default 'POST'
+     */
+    transferVia?: GqlTransferOption;
+    /**
+     * Subroute to use for the query.
+     */
+    route?: Route;
+}
+type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any, any>;
+type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any, any>;
+type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = Omit<RestQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;
+type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Store extends EntityStore<unknown>, Data, Id> = Omit<GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;
+type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams & WithMock<unknown>;
+interface WithHeaders {
+    /**
+     * The headers to send with the query.
+     */
+    headers?: Record<string, string>;
+}
+interface QueryMockConfig<MockResponse> {
+    /**
+     * The mock response to use for the query.
+     */
+    response?: MockResponse;
+    /**
+     * The mock error to use for the query.
+     */
+    error?: RequestError;
+    /**
+     * The delay in milliseconds to wait before resolving the mock.
+     * If progress is enabled, the delay will be used for each progress event.
+     * @default 200
+     */
+    delay?: number;
+    /**
+     * Whether to report progress for the mock.
+     * For testing e.g. file uploads.
+     */
+    progress?: {
+        /**
+         * The number of progress events to report.
+         * @default 5
+         */
+        eventCount?: number;
+        /**
+         * The type of progress event to report.
+         * @default 'upload'
+         */
+        eventType?: 'download' | 'upload';
+        /**
+         * The total size of the file to report progress for in bytes.
+         * @default 1_000_000 (1MB)
+         */
+        fileSize?: number;
+        /**
+         * If true, the total size of the file will be omitted from the progress event.
+         * Useful for testing e.g. download progress when the server does not provide a total size.
+         */
+        omitTotal?: boolean;
+        /**
+         * If true, the partial text will be omitted from the progress event.
+         * Useful for testing e.g. download progress when the server does not provide a partial text.
+         */
+        omitPartialText?: boolean;
+    };
+    /**
+     * This will mock the request failing and getting retried 3 times. After, the request will succeed with the provided response.
+     * Can not be used with `progress` enabled.
+     * @default false
+     */
+    retryIntoResponse?: boolean;
+}
+interface WithMock<MockResponse> {
+    mock?: QueryMockConfig<MockResponse>;
+}
+interface QueryConfig {
+    /**
+     * Whether this query should be added to the internal query store.
+     *
+     * Generally this should be left on `false` unless you know what you are doing.
+     * @default false
+     */
+    skipQueryStore?: boolean;
+    /**
+     * The cache key to use for this query.
+     * Useful for queries that are equal but should be stored separately.
+     * Will be generated automatically if not provided.
+     *
+     * Generally this should be left on `undefined` unless you know what you are doing.
+     */
+    queryStoreCacheKey?: string;
+}
+interface WithConfig {
+    /**
+     * Additional configuration for this query.
+     */
+    config?: QueryConfig;
+}
+interface WithInjector {
+    injector?: Injector;
+}
+interface WithVariables {
+    /**
+     * The variables for the query. (graphql only)
+     */
+    variables?: Record<string, unknown>;
+}
+interface WithBody {
+    /**
+     * The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
+     */
+    body?: unknown;
+}
+interface WithQueryParams {
+    /**
+     * The query parameters for the query. (after the ? in the url)
+     */
+    queryParams?: QueryParams;
+}
+interface WithPathParams {
+    /**
+     * The path parameters for the query. (in front of the ? in the url)
+     */
+    pathParams?: PathParams;
+}
+type QueryTrigger = 'program' | 'poll' | 'auto';
+type EmptyObject = {};
+interface ExecuteQueryOptions {
+    /**
+     * Whether to skip the cache for this query. This will force the query to be executed. It might still be caught by the native browser cache.
+     * @default false
+     */
+    skipCache?: boolean;
+    /**
+     * Whether to cancel the previous request if it is still loading.
+     * @default false
+     */
+    cancelPrevious?: boolean;
+}
+type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
+    pathParams: infer PathParams;
+} ? (p: PathParams) => RouteString : RouteString;
+type RouteString = `/${string}`;
+type AnyRoute = ((p: PathParams) => string) | RouteString;
+interface PollConfig {
+    /**
+     * The interval in milliseconds to poll the query.
+     */
+    interval: number;
+    /**
+     * A observable that will stop the polling when it emits.
+     */
+    takeUntil: Observable<unknown>;
+    /**
+     * Whether to trigger the query immediately after polling starts.
+     */
+    triggerImmediately?: boolean;
+}
+declare const enum QueryStateType {
+    Prepared = "PREPARED",
+    Loading = "LOADING",
+    Success = "SUCCESS",
+    Failure = "FAILURE",
+    Cancelled = "CANCELLED"
+}
+interface Prepared {
+    type: QueryStateType.Prepared;
+    meta: QueryStateMeta;
+}
+interface Success<Response = unknown> {
+    type: QueryStateType.Success;
+    response: Response;
+    headers: RequestHeaders;
+    meta: QueryStateSuccessMeta;
+}
+interface Failure {
+    type: QueryStateType.Failure;
+    error: RequestError;
+    meta: QueryStateMeta;
+}
+interface Loading {
+    type: QueryStateType.Loading;
+    meta: QueryStateMeta;
+    partialText?: string;
+    progress?: RequestProgress;
+}
+interface Cancelled {
+    type: QueryStateType.Cancelled;
+    meta: QueryStateMeta;
+}
+interface QueryStateMeta {
+    id: number;
+    triggeredVia: QueryTrigger;
+    isWaitingForRetry?: boolean;
+    retryNumber?: number;
+    retryDelay?: number;
+}
+interface QueryStateSuccessMeta extends QueryStateMeta {
+    expiresAt?: number;
+}
+type QueryState<Response = unknown> = Loading | Success<Response> | Failure | Cancelled | Prepared;
+type QueryStateResponseOf<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
+type AnyQuery = Query<any, any, any, any, any, any>;
+type AnyQueryCreatorCollection = {
+    [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
+};
+type QueryCollectionOf<T extends {
+    [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
+}> = {
+    [K in keyof T]: {
+        type: K;
+        query: ConstructQuery<T[K]>;
+    };
+}[keyof T];
+type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
+type QueryOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyLegacyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
+type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;
+type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;
+type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQueryCollection ? T['type'] : never;
+type QueryCollectionWithNullableQuery<T extends AnyQueryCollection | null> = T extends null ? never : {
+    [K in keyof T]: T[K] extends string ? T[K] : T[K] | null;
+};
+interface ResetPageOnErrorOperatorConfig<J extends QueryForm<any>> {
+    /**
+     * The query form to reset the page of.
+     */
+    queryForm: J;
+    /**
+     * The key of the page control in the query form.
+     * @default 'page'
+     */
+    pageControlKey?: string;
+}
+
+declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
+    private readonly _client;
+    readonly _id: number;
+    private _currentLocalId;
+    private _pollingSubscription;
+    private _onAbort$;
+    private _currentPollConfig;
+    private readonly _state$;
+    private get _nextId();
+    get state$(): Observable<QueryState<Data>>;
+    /**
+     * The current state of the query.
+     *
+     * **Warning!** This differs from the `state$` observable in that it does not use the query store. Thus, the response data might be outdated.
+     * Use `state$` (or `firstValueFrom(state$)`) the most up-to-date data.
+     */
+    get rawState(): QueryState<Response>;
+    get isExpired(): boolean;
+    get isInUse(): boolean;
+    get isPolling(): boolean;
+    get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
+    get store(): Store | null;
+    get canBeCached(): boolean;
+    get _isInMockMode(): boolean;
+    constructor(_client: QueryClient, 
+    /**
+     * @internal
+     */
+    _queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 
+    /**
+     * @internal
+     */
+    _routeWithParams: Route, 
+    /**
+     * @internal
+     */
+    _arguments: Arguments, 
+    /**
+     * @internal
+     */
+    _queryStoreKey: string);
+    execute(options?: ExecuteQueryOptions): this;
+    abort(): this;
+    poll(config: PollConfig): this;
+    stopPolling(): this;
+    pausePolling(): this;
+    resumePolling(): this;
+    onSuccess(callback: (response: Data) => void): this;
+    onFailure(callback: (error: RequestError<unknown>) => void): this;
+    private _getBearerAuthProvider;
+    private _updateEntityState;
+    private _transformState;
+    private _updateState;
+    private _mockRequest;
+}
+
+type OmitNull<T> = T extends null ? never : T;
+declare function filterSuccess(): <T extends QueryState | null, Response extends QueryStateResponseOf<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response>>;
+declare function ignoreAutoRefresh(): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+declare function filterFailure(): <T extends QueryState | null>(source: Observable<T>) => Observable<Failure>;
+declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+declare function takeUntilResponse(config?: {
+    excludeNull?: boolean;
+}): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+declare function filterNull(): <T>(source: Observable<T>) => Observable<OmitNull<T>>;
+declare function switchQueryState(): <T extends AnyQuery | null, Data extends QueryDataOf<T>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
+declare function switchQueryCollectionState(): <T extends AnyQueryCollection | null, Data extends AnyQueryCollectionData<OmitNull<T>>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
+declare const resetPageOnError: <T extends AnyQuery | null | undefined, J extends QueryForm<any>>(config: ResetPageOnErrorOperatorConfig<J>) => (source: Observable<T>) => Observable<QueryState<any> | T>;
+declare const isQueryStateLoading: (state: QueryState | null | undefined) => state is Loading;
+declare const isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success;
+declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
+declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
+declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
+declare const isAutoRefresh: (state: QueryState | null | undefined) => boolean;
+declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
+declare const isGqlQueryConfig: <Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, Store extends EntityStore<unknown>, Data, Id>(config: unknown) => config is GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>;
+declare const isQuery: <T extends AnyQuery>(query: unknown) => query is T;
+declare const isQueryCollection: <T extends AnyQueryCollection>(query: unknown) => query is T;
+/**
+ * @deprecated Use `createQueryCollectionSubject` instead. Will be removed in v6.
+ */
+declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T) => BehaviorSubject<R | null>;
+declare const createQueryCollectionSubject: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => BehaviorSubject<R | null>;
+declare const createQueryCollectionSignal: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => _angular_core.WritableSignal<R | null>;
+declare const extractQuery: <T extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>(v: T) => _ethlete_query.Query<any, any, any, any, any, any> | (T & AnyLegacyQuery) | LegacyQuery<any, LegacyArgs, Route, any, any, any, Query$1<any>> | null;
+declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
+declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryArgsOf<QC>, Response extends QueryResponseOf<QC>, Store extends QueryStoreOf<QC>, Data extends QueryDataOf<QC>, Route extends RouteType<Arguments>, Id extends QueryStoreIdOf<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response | undefined>(config: {
+    creator: QC;
+    args?: OverrideArguments;
+    response?: OverrideResponse;
+}) => QueryCreator<OverrideArguments, OverrideResponse, Route, Store, Data, Id>;
+declare const computeQueryMethod: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+declare const computeQueryBody: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+    method: Method;
+    args?: BaseArguments;
+}) => unknown;
+declare const computeQueryAuthHeader: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+}) => Record<string, string> | null;
+declare const computeQueryHeaders: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+    args?: BaseArguments;
+}) => RequestHeaders | undefined;
+declare const computeQueryQueryParams: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+    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 }: {
+    rawResponse: T;
+    response: T;
+    args: Args;
+    entity: Entity;
+}) => {
+    response: T & {
+        items: unknown[];
+    };
+    rawResponse: T & {
+        items: unknown[];
+    };
+} | null;
+
+interface QueryClientConfig {
+    /**
+     * The api base route. Should **not** end with a trailing slash.
+     * @example 'https://api.example.com'
+     */
+    baseRoute: string;
+    /**
+     * Logging configuration for debugging.
+     */
+    logging?: {
+        /**
+         * Log all query state changes.
+         */
+        queryStateChanges?: boolean;
+        /**
+         * Log query state garbage collector runs.
+         */
+        queryStateGarbageCollector?: boolean;
+        /**
+         * Log if subscriptions are made to queries that are in the `prepared` state.
+         * This usually indicates that the `.execute()` method was forgotten.
+         */
+        preparedQuerySubscriptions?: boolean;
+    };
+    /**
+     * Request options.
+     */
+    request?: {
+        /**
+         * Adapter function used for extracting the time until the response is invalid.
+         * The default uses the `cache-control` (`max-age` & `s-maxage`), `age` and `expires` headers.
+         * Should return a number in seconds.
+         */
+        cacheAdapter?: CacheAdapterFn$1;
+        /**
+         * Default headers to be sent with every request.
+         * Will be overridden by headers passed to the query.
+         * Do not include the `Authorization` header here. Use an `AuthProvider` instead.
+         */
+        headers?: RequestHeaders | RequestHeadersMethodMap;
+        /**
+         * Whether to automatically refresh expired queries when the window regains focus.
+         * @default true
+         */
+        autoRefreshQueriesOnWindowFocus?: boolean;
+        /**
+         * Whether to automatically stop polling queries when the window loses focus.
+         * Polling will resume when the window regains focus.
+         * @default true
+         */
+        enableSmartPolling?: boolean;
+        /**
+         * A retry function to be used for all queries.
+         * @default shouldRetryRequest()
+         */
+        retryFn?: RequestRetryFn;
+        /**
+         * Configuration options for all graphql queries.
+         */
+        gql?: {
+            /**
+             * Determines if the query should be sent via GET or POST.
+             * - `GET`: The query will be sent via query parameters.
+             * - `POST`: The query will be sent via the body.
+             * @default 'POST'
+             */
+            transferVia?: GqlTransferOption;
+        };
+        /**
+         * Configuration options for all query strings.
+         */
+        queryParams?: BuildQueryStringConfig;
+    };
+    /**
+     * Parent query client.
+     * Used for sharing the same auth provider.
+     */
+    parent?: QueryClient;
+}
+
+declare class QueryClient {
+    private _clientConfig;
+    get config(): QueryClientConfig;
+    get authProvider(): AuthProvider | null;
+    get authProvider$(): rxjs.Observable<AuthProvider | null>;
+    private readonly _authProvider$;
+    constructor(_clientConfig: QueryClientConfig);
+    get: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    post: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    put: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    patch: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    delete: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    fetch: <Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Id, Store extends EntityStore<unknown> = EntityStore<unknown>, Data = Response>(queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    setAuthProvider: (authProvider: AuthProvider) => void;
+    setDefaultHeaders: (config: {
+        headers: RequestHeaders | RequestHeadersMethodMap | null;
+        refreshQueriesInUse?: boolean;
+    }) => void;
+    clearAuthProvider: () => void;
+    _updateBaseRoute: (route: string) => void;
+}
+
+declare const shouldCacheQuery: (method: Method) => method is "GET" | "HEAD" | "OPTIONS" | "GQL_QUERY";
+declare const buildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;
+
+declare class QueryStore {
+    private _config?;
+    private _garbageCollector;
+    private _isInLowResourceMode;
+    private _lastBlurTimestamp;
+    private _storeChange$;
+    private _queryCreated$;
+    readonly storeChange$: rxjs.Observable<string>;
+    readonly queryCreated$: rxjs.Observable<AnyQuery>;
+    constructor(_config?: {
+        enableChangeLogging?: boolean;
+        enableGarbageCollectorLogging?: boolean;
+        autoRefreshQueriesOnWindowFocus?: boolean;
+        enableSmartPolling?: boolean;
+    } | undefined);
+    add(id: string, query: AnyQuery): void;
+    get<T extends AnyQuery>(id: string): T | null;
+    remove(id: string): void;
+    forEach(callback: (value: AnyQuery, key: string) => void): void;
+    refreshQueriesInUse(config?: {
+        ignoreCacheValidity?: boolean;
+        purgeUnused?: boolean;
+    }): void;
+    private _initSmartQueryHandling;
+    private _logState;
+    private _initGarbageCollector;
+    private _stopGarbageCollector;
+    private _runGarbageCollector;
+    private _logGarbageCollector;
+}
+
+type QueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id>;
+type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
+type QueryArgsOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : T extends Query<any, infer Args, any, any, any, any> ? Args : T extends LegacyQuery<any, infer Args, any, any, any, any, any> ? Args : T extends LegacyQueryCreator<infer Args, any, any, any, any> ? LegacyArgumentsOfQueryArgs<Args> : never;
+type QueryResponseOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, infer Response, any, any, any, any> ? Response : T extends Query<infer Response, any, any, any, any, any> ? Response : T extends LegacyQuery<infer Response, any, any, any, any, any, any> ? Response : T extends LegacyQueryCreator<any, infer Response, any, any, any> ? Response : never;
+type QueryRouteOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, infer Route, any, any, any> ? Route : T extends Query<any, any, infer Route, any, any, any> ? Route : T extends LegacyQuery<any, any, infer Route, any, any, any, any> ? Route : T extends LegacyQueryCreator<infer Args, any, any, any, any> ? RouteType<LegacyArgumentsOfQueryArgs<Args>> : never;
+type QueryStoreOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, any, infer Store, any, any> ? Store : T extends Query<any, any, any, infer Store, any, any> ? Store : T extends LegacyQuery<any, any, any, infer Store, any, any, any> ? Store : T extends LegacyQueryCreator<any, any, infer Store, any, any> ? Store : never;
+type QueryDataOf<T extends AnyQueryCreator | AnyLegacyQuery | AnyLegacyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, infer Data, any> ? Data : T extends Query<any, any, any, any, infer Data, any> ? Data : T extends LegacyQuery<any, any, any, any, infer Data, any, any> ? Data : T extends LegacyQueryCreator<any, any, any, any, infer Data> ? Data : never;
+type QueryStoreIdOf<T extends AnyQueryCreator | AnyQuery | AnyLegacyQuery | AnyLegacyQueryCreator | null> = T extends QueryCreator<any, any, any, any, any, infer StoreId> ? StoreId : T extends Query<any, any, any, any, any, infer StoreId> ? StoreId : T extends LegacyQuery<any, any, any, any, any, infer StoreId, any> ? StoreId : T extends LegacyQueryCreator<any, any, any, infer StoreId, any> ? StoreId : never;
+type ConstructQuery<T extends AnyQueryCreator | AnyLegacyQueryCreator> = ReturnType<T['prepare']>;
+
+declare class QueryCreator<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
+    private _queryConfig;
+    private _client;
+    private _store;
+    constructor(_queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, _client: QueryClient, _store: QueryStore);
+    prepare: QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>;
+    createSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+    createSignal: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => _angular_core.WritableSignal<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+    /**
+     * @deprecated Use `myQuery.createSubject()` or `myQuery.createSignal()` instead. Will be removed in v6.
+     */
+    behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null) => BehaviorSubject<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+}
+
+interface AuthProvider {
+    /**
+     * The up to date auth header.
+     * This will automatically get injected into every query that has the `secure` property set to `true`.
+     */
+    header: Record<string, string>;
+}
+interface AuthProviderBasicConfig {
+    /**
+     * Basic auth username
+     */
+    username: string;
+    /**
+     * Basic auth password
+     */
+    password: string;
+}
+interface AuthProviderCustomHeaderConfig {
+    /**
+     * The custom header name
+     * @example `X-Api-Key`
+     */
+    name: string;
+    /**
+     * The custom header value
+     * @example `myApiKey`
+     */
+    value: string;
+}
+interface AuthProviderBearerConfig<T extends AnyQueryCreator> {
+    /**
+     * The initial jwt
+     */
+    token?: string;
+    /**
+     * Refresh token configuration
+     */
+    refreshConfig?: BearerRefreshConfig<T>;
+}
+interface BearerRefreshConfig<T extends AnyQueryCreator> {
+    /**
+     * The query used to trade the refresh token for a new token response.
+     */
+    queryCreator: T;
+    /**
+     * Determines if the token should be refreshed if **any** query returns a 401 response.
+     * @default true
+     */
+    refreshOnUnauthorizedResponse?: boolean;
+    /**
+     * The initial refresh token
+     */
+    token?: string;
+    /**
+     * The cookie name where the refresh token is stored
+     */
+    cookieName?: string;
+    /**
+     * The domain of the cookie. If not set, the current origin will be used.
+     *
+     * @example
+     * "https://example.com" -> "example.com"
+     * "https://sub.example.com" -> "example.com"
+     */
+    cookieDomain?: string;
+    /**
+     * The days until the cookie expires
+     * @default 30
+     */
+    cookieExpiresInDays?: number;
+    /**
+     * The path of the cookie
+     * @default '/'
+     */
+    cookiePath?: string;
+    /**
+     * Enable or disable the cookie
+     * @default true
+     */
+    cookieEnabled?: boolean;
+    /**
+     * The same site property of the cookie
+     * @default 'lax'
+     */
+    cookieSameSite?: 'strict' | 'none' | 'lax';
+    /**
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 (5 minutes)
+     */
+    refreshBuffer?: number;
+    /**
+     * The expires in property name inside the jwt body
+     * @default 'exp'
+     */
+    expiresInPropertyName?: string;
+    /**
+     * Determines when the token should be refreshed.
+     * @default AuthBearerRefreshStrategy.BeforeExpiration
+     */
+    strategy?: AuthBearerRefreshStrategy;
+    /**
+     * Adapter function used to build the request body for the refresh request.
+     * @default { body: { refreshToken: "refreshToken" } }
+     */
+    requestArgsAdapter?: (tokens: {
+        token: string | null;
+        refreshToken: string;
+    }) => QueryArgsOf<T>;
+    /**
+     * Adapter function used to extract the token and refreshToken from the response.
+     * @default { token: "token", refreshToken: "refreshToken" }
+     */
+    responseAdapter?: (response: NonNullable<QueryResponseOf<T>>) => TokenResponse;
+}
+declare const enum AuthBearerRefreshStrategy {
+    /**
+     * Automatically refresh the token 5 minutes before expiration.
+     * The time can be configured with the `refreshBuffer` property.
+     */
+    BeforeExpiration = "beforeExpiration"
+}
+interface TokenResponse {
+    /**
+     * The access token used inside the authorization http header.
+     */
+    token: string | null;
+    /**
+     * The refresh token used for requesting a new token response once the current tokes is expired.
+     * This property is required if the bearer refresh config is set.
+     */
+    refreshToken: string | null;
+}
+
+declare class CustomHeaderAuthProvider implements AuthProvider {
+    _config: AuthProviderCustomHeaderConfig;
+    get header(): {
+        [x: string]: string;
+    };
+    constructor(_config: AuthProviderCustomHeaderConfig);
+    cleanUp(): void;
+}
+
+declare class BasicAuthProvider implements AuthProvider {
+    _config: AuthProviderBasicConfig;
+    get header(): {
+        Authorization: string;
+    };
+    private get _basicAuthString();
+    constructor(_config: AuthProviderBasicConfig);
+    cleanUp(): void;
+}
+
+declare class BearerAuthProvider<T extends AnyQueryCreator> implements AuthProvider {
+    _config: AuthProviderBearerConfig<T>;
+    private readonly _destroy$;
+    private readonly _currentRefreshQuery$;
+    private readonly _tokens$;
+    get header(): {
+        Authorization: string;
+    };
+    get tokens$(): rxjs.Observable<TokenResponse>;
+    get tokens(): TokenResponse;
+    get currentRefreshQuery$(): rxjs.Observable<ConstructQuery<T> | null>;
+    get currentRefreshQuery(): ConstructQuery<T> | null;
+    get shouldRefreshOnUnauthorizedResponse(): boolean;
+    constructor(_config: AuthProviderBearerConfig<T>);
+    cleanUp(): void;
+    enableCookie(): void;
+    disableCookie(): void;
+    private _setCookie;
+    private _deleteCookie;
+    private _prepareForRefresh;
+}
+
+declare const isBasicAuthProvider: (authProvider: AuthProvider) => authProvider is BasicAuthProvider;
+declare const isBearerAuthProvider: <T extends AnyQueryCreator>(authProvider: AuthProvider) => authProvider is BearerAuthProvider<T>;
+declare const isCustomHeaderAuthProvider: (authProvider: AuthProvider) => authProvider is CustomHeaderAuthProvider;
+declare const decryptBearer: <Result = Record<string, unknown>>(token: string) => Result | null;
+
+interface ClassValidatorError {
+    statusCode: HttpStatusCode;
+    message: string[];
+    error: string;
+}
+
+declare const isClassValidatorError: (error: unknown) => error is ClassValidatorError;
+
+interface QueryClientDevtoolsOptions {
+    displayName?: string;
+    client: QueryClient;
+}
+declare const QUERY_CLIENT_DEVTOOLS_TOKEN: InjectionToken<QueryClientDevtoolsOptions[]>;
+declare const provideQueryClientForDevtools: (queryClient: QueryClientDevtoolsOptions) => {
+    provide: InjectionToken<QueryClientDevtoolsOptions[]>;
+    useValue: QueryClientDevtoolsOptions;
+    multi: boolean;
+};
+
+type QueryDevtoolsSnapLayout = 'full' | 'left' | 'right' | 'bottom' | 'top';
+type QueryListMode = 'live' | 'history';
+type QueryViewMode = 'query' | 'authProvider';
+declare class QueryDevtoolsComponent {
+    private readonly _cdr;
+    protected readonly _destroy$: rxjs.Observable<boolean>;
+    protected readonly queryClientConfigs: QueryClientDevtoolsOptions[];
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly isTranslucent: _angular_core.WritableSignal<boolean>;
+    protected readonly snapLayout: _angular_core.WritableSignal<QueryDevtoolsSnapLayout>;
+    protected readonly queryListMode: _angular_core.WritableSignal<QueryListMode>;
+    protected readonly viewMode: _angular_core.WritableSignal<QueryViewMode>;
+    protected showResponse: _angular_core.WritableSignal<boolean>;
+    protected showRawResponse: _angular_core.WritableSignal<boolean>;
+    protected showQueryConfig: _angular_core.WritableSignal<boolean>;
+    protected showEntityStoreValue: _angular_core.WritableSignal<boolean>;
+    protected showArguments: _angular_core.WritableSignal<boolean>;
+    protected selectedClientIdCtrl: FormControl<number | null>;
+    protected readonly selectedClientId: _angular_core.Signal<number | null | undefined>;
+    protected readonly selectedQueryId: _angular_core.WritableSignal<number | null>;
+    protected readonly selectedClientConfig: _angular_core.Signal<QueryClientDevtoolsOptions>;
+    protected readonly queryStore: _angular_core.Signal<_ethlete_query.QueryStore>;
+    protected readonly queryStore$: rxjs.Observable<_ethlete_query.QueryStore>;
+    private readonly _queries$;
+    protected readonly queries: _angular_core.Signal<AnyQuery[] | undefined>;
+    protected readonly selectedQuery: _angular_core.Signal<AnyQuery | null>;
+    protected readonly selectedQuery$: rxjs.Observable<AnyQuery | null>;
+    protected selectedQueryEntityStore: _angular_core.Signal<EntityStore<unknown> | null>;
+    protected readonly selectedQueryEntityStore$: rxjs.Observable<EntityStore<unknown> | null>;
+    protected readonly selectedQueryEntityStoreValue$: rxjs.Observable<Record<string, unknown> | null>;
+    protected readonly queryHistory$: BehaviorSubject<AnyQuery[]>;
+    protected readonly stringifiedQueryConfig: _angular_core.Signal<{
+        query: string;
+        transferVia: GqlTransferOption | undefined;
+        method: _ethlete_query.Method;
+        secure: boolean | undefined;
+        route: any;
+        reportProgress: boolean | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
+        withCredentials: boolean | undefined;
+        autoRefreshOn: QueryAutoRefreshConfig | undefined;
+        enableSmartPolling: boolean | undefined;
+        hasEntityStore: boolean;
+    } | {
+        method: _ethlete_query.Method;
+        secure: boolean | undefined;
+        route: any;
+        reportProgress: boolean | undefined;
+        responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
+        withCredentials: boolean | undefined;
+        autoRefreshOn: QueryAutoRefreshConfig | undefined;
+        enableSmartPolling: boolean | undefined;
+        hasEntityStore: boolean;
+    } | null>;
+    protected readonly authProvider: _angular_core.Signal<AuthProvider | null | undefined>;
+    protected readonly authProviderDetails: _angular_core.Signal<{
+        readonly type: "CustomHeaderAuthProvider";
+        readonly header: () => {
+            [x: string]: string;
+        };
+        readonly provider: CustomHeaderAuthProvider;
+        readonly config: {
+            readonly name: string;
+            readonly value: string;
+            readonly username?: undefined;
+            readonly password?: undefined;
+            readonly token?: undefined;
+            readonly refreshConfig?: undefined;
+        };
+    } | {
+        readonly type: "BasicAuthProvider";
+        readonly header: () => {
+            Authorization: string;
+        };
+        readonly provider: BasicAuthProvider;
+        readonly config: {
+            readonly username: string;
+            readonly password: string;
+            readonly name?: undefined;
+            readonly value?: undefined;
+            readonly token?: undefined;
+            readonly refreshConfig?: undefined;
+        };
+    } | {
+        readonly type: "BearerAuthProvider";
+        readonly header: () => {
+            Authorization: string;
+        };
+        readonly provider: BearerAuthProvider<_ethlete_query.AnyQueryCreator>;
+        readonly config: {
+            readonly token: string | undefined;
+            readonly refreshConfig: {
+                readonly refreshOnUnauthorizedResponse: boolean | "true (default)";
+                readonly token: string | undefined;
+                readonly cookieName: string | undefined;
+                readonly cookieDomain: string;
+                readonly cookieExpiresInDays: number | "30 (default)";
+                readonly cookiePath: string;
+                readonly cookieEnabled: boolean | "true (default)";
+                readonly cookieSameSite: "strict" | "none" | "lax" | "lax (default)";
+                readonly refreshBuffer: number | "30000 (default)";
+                readonly expiresInPropertyName: string;
+                readonly strategy: AuthBearerRefreshStrategy | "AuthBearerRefreshStrategy.BeforeExpiration (default)";
+                readonly requestArgsAdapter: "custom" | "default";
+                readonly responseAdapter: "custom" | "default";
+            };
+            readonly name?: undefined;
+            readonly value?: undefined;
+            readonly username?: undefined;
+            readonly password?: undefined;
+        };
+    } | {
+        readonly type: "UnknownAuthProvider";
+        readonly header: () => Record<string, string>;
+        readonly provider: AuthProvider;
+        readonly config: {
+            readonly name?: undefined;
+            readonly value?: undefined;
+            readonly username?: undefined;
+            readonly password?: undefined;
+            readonly token?: undefined;
+            readonly refreshConfig?: undefined;
+        };
+    } | null>;
+    constructor();
+    protected trackByClient: TrackByFunction<QueryClientDevtoolsOptions>;
+    protected trackByQuery: TrackByFunction<AnyQuery>;
+    protected toggleOpen(): void;
+    protected toggleTranslucent(): void;
+    protected toggleShowResponse(): void;
+    protected toggleShowQueryConfig(): void;
+    protected toggleShowRawResponse(): void;
+    protected toggleShowEntityStoreValue(): void;
+    protected toggleShowArguments(): void;
+    protected selectSnapLayout(layout: QueryDevtoolsSnapLayout): void;
+    protected selectQueryListMode(mode: QueryListMode): void;
+    protected selectViewMode(mode: QueryViewMode): void;
+    protected selectQuery(query: AnyQuery): void;
+    protected clearQueryHistory(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsComponent, "et-query-devtools", never, {}, {}, never, never, true, never>;
+}
+
+declare class QueryShortNamePipe implements PipeTransform {
+    transform(value: AnyQuery): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryShortNamePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<QueryShortNamePipe, "queryShortName", true>;
+}
+
+interface QueryContext<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null> {
+    /**
+     * The queries's response data.
+     */
+    $implicit: QueryDataOf<QueryOf<Q>> | null;
+    /**
+     * The queries's response data.
+     */
+    etQuery: QueryDataOf<QueryOf<Q>> | null;
+    /**
+     * The query used inside this directive. Useful if for instance the query gets unwrapped via async pipe inside the directive.
+     */
+    query: QueryOf<Q> | null;
+    /**
+     * Is true when the query is triggered by user interaction.
+     */
+    loading: boolean;
+    /**
+     * Is true when the query is triggered by either polling or auto refresh event.
+     */
+    refreshing: boolean;
+    /**
+     * The query's progress state.
+     */
+    progress: RequestProgress | null;
+    /**
+     * The query's error state.
+     */
+    error: RequestError<unknown> | null;
+    /**
+     * The query's scope (only available when the query is a collection)
+     */
+    scope: QueryCollectionKeysOf<Q> | null;
+}
+declare class QueryDirective<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {
+    private _mainTemplateRef;
+    private _viewContainerRef;
+    private _errorHandler;
+    private _cdr;
+    private _isMainViewCreated;
+    private _subscription;
+    private readonly _viewContext;
+    get query(): Q;
+    set query(v: Q);
+    private _query;
+    get cache(): boolean;
+    set cache(v: boolean);
+    private _cache;
+    static ngTemplateContextGuard<Q extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<Q>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _subscribeToQuery;
+    private _updateView;
+    private _renderMainView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, { "query": { "alias": "etQuery"; "required": false; }; "cache": { "alias": "etQueryCache"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+type AppendItemsLocation = 'start' | 'end';
+interface PageParamCalculatorOptions {
+    page: number;
+    totalPages: number | null;
+    itemsPerPage: number;
+}
+interface TotalPagesExtractorOptions<Arguments extends BaseArguments | undefined, QueryResponse> {
+    response: QueryResponse;
+    itemsPerPage: number;
+    args: Arguments;
+}
+interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Arguments extends BaseArguments | undefined, QueryResponse, InfinityResponse extends unknown[]> {
+    /**
+     * The query creator to use for fetching pages.
+     */
+    queryCreator: QueryCreator;
+    /**
+     * The interval in milliseconds to poll on. If not provided, polling will be disabled.
+     * @default undefined
+     */
+    pollingInterval?: number;
+    /**
+     * The args that will be merged with the page arg.
+     */
+    defaultArgs?: Arguments & WithHeaders;
+    pageParam?: {
+        /**
+         * The location where the page param is in request.
+         *
+         * @default "query"
+         */
+        location?: InfinityQueryParamLocation;
+        /**
+         * Used as page param name.
+         *
+         * @default "page"
+         */
+        key?: string;
+        /**
+         * A function that calculates the page value for the next request.
+         * E.g. if the pagination is done with a `skip` param, the `pageParamName` should be `skip` and this function should return the correct value.
+         */
+        valueCalculator?: (data: PageParamCalculatorOptions) => number;
+    };
+    limitParam?: {
+        /**
+         * The location where the limit param is in request.
+         *
+         * @default "query"
+         */
+        location?: InfinityQueryParamLocation;
+        /**
+         * Used as limit param name.
+         *
+         * @default "limit"
+         */
+        key?: string;
+        /**
+         * The value of the limit param.
+         *
+         * @default 10
+         */
+        value?: number;
+    };
+    response: {
+        /**
+         * Determines if the response should get reversed before appending to the data array.
+         *
+         * @default false
+         */
+        reverse?: boolean;
+        /**
+         * Determines where to put the new items in the data array.
+         *
+         * @default "end"
+         */
+        appendItemsTo?: AppendItemsLocation;
+        /**
+         * The type of the array that will be created by the infinite query.
+         */
+        arrayType: InfinityResponse;
+        /**
+         * A function that returns the data array from the response.
+         * This function should return the type provided in `responseArrayType`.
+         */
+        valueExtractor?: (response: QueryResponse) => InfinityResponse;
+        /**
+         * The property in the response that contains the total page count.
+         *
+         * @default "totalPages"
+         */
+        totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryArgsOf<QueryCreator> & WithHeaders, QueryResponse>) => number;
+    };
+}
+type OmitUndefined<T> = T extends undefined ? never : T;
+type AnyInfinityQueryConfig = InfinityQueryConfig<any, any, any, any>;
+type AnyInfinityQuery = InfinityQuery<any, any, any, any, any>;
+type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryDataOf<QueryCreator>, InfinityResponse>;
+type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig | null> = InfinityQuery<NonNullable<Cfg>['queryCreator'], ConstructQuery<NonNullable<Cfg>['queryCreator']>, QueryArgsOf<NonNullable<Cfg>['queryCreator']>, QueryDataOf<NonNullable<Cfg>['queryCreator']>, NonNullable<Cfg>['response']['arrayType']>;
+
+declare class InfinityQuery<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Query extends ConstructQuery<QueryCreator>, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]> {
+    private _config;
+    private _destroy$;
+    private readonly _queries$;
+    private readonly _currentPage$;
+    private readonly _currentCalculatedPage$;
+    private readonly _totalPages$;
+    private readonly _itemsPerPage$;
+    private readonly _data$;
+    private readonly _lastQuery$;
+    get currentPage$(): Observable<number | null>;
+    get currentPage(): number | null;
+    get currentCalculatedPage$(): Observable<number | null>;
+    get currentCalculatedPage(): number | null;
+    get totalPages$(): Observable<number | null>;
+    get totalPages(): number | null;
+    get itemsPerPage$(): Observable<number>;
+    get itemsPerPage(): number;
+    get data$(): Observable<InfinityResponse | null>;
+    get currentQuery$(): Observable<Query | null>;
+    constructor(_config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>, _destroy$: Observable<boolean>);
+    nextPage(): void;
+    reset(newConfig?: Omit<InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>, 'queryCreator' | 'response'>): void;
+    private _prepareArgs;
+    private _getPageParamLocation;
+}
+
+declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryDataOf<QueryCreator>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
+declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;
+
+interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> {
+    $implicit: Q['response']['arrayType'] | null;
+    etInfinityQuery: Q['response']['arrayType'] | null;
+    loading: boolean;
+    error: RequestError<unknown> | null;
+    isFirstLoad: boolean;
+    canLoadMore: boolean;
+    currentPage: number | null;
+    currentCalculatedPage: number | null;
+    totalPages: number | null;
+    itemsPerPage: number | null;
+    currentQuery: ConstructQuery<Q['queryCreator']> | null;
+}
+declare const INFINITY_QUERY_TOKEN: InjectionToken<InfinityQueryDirective<any>>;
+declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> {
+    private readonly _queryConfigChanged$;
+    private readonly _viewContext;
+    private _infinityQueryInstance;
+    private readonly _destroy$;
+    private readonly _cdr;
+    private readonly _viewContainerRef;
+    private readonly _mainTemplateRef;
+    private readonly _errorHandler;
+    private readonly _delayable;
+    private readonly _data$;
+    get infinityQuery(): Q;
+    set infinityQuery(v: Q);
+    private _infinityQuery;
+    get context(): InfinityQueryContext<Q>;
+    get instance(): InfinityQueryOf<Q> | null;
+    get data$(): rxjs.Observable<Q["response"]["arrayType"]>;
+    data: _angular_core.Signal<Q["response"]["arrayType"]>;
+    static ngTemplateContextGuard<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
+    constructor();
+    private _setupInfinityQuery;
+    loadNextPage(): void;
+    reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
+    private _cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[etInfinityQuery]", ["etInfinityQuery"], { "infinityQuery": { "alias": "etInfinityQuery"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.DelayableDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _infinityQuery;
+    private _destroy;
+    private _observer;
+    click$: rxjs.Observable<unknown>;
+    scrollContainerSelector: string | null;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _setupIntersectionObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfinityQueryTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[etInfinityQueryTrigger], et-infinity-query-trigger", never, { "scrollContainerSelector": { "alias": "scrollContainerSelector"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const buildErrorMessage: (code: string, message: string) => string;
+declare class QueryError extends Error {
+    data?: unknown;
+    constructor(code: string, message: string, data?: unknown);
+}
+declare const invalidBaseRouteError: (data: unknown) => QueryError;
+declare const invalidRouteError: (data: unknown) => QueryError;
+declare const pathParamsMissingInRouteFunctionError: (data: unknown) => QueryError;
+declare const queryStateAlreadyHasKeyError: (data: unknown) => QueryError;
+declare const queryStateDoesNotContainKeyError: (data: unknown) => QueryError;
+declare const queryStateCannotTransformError: (data: unknown) => QueryError;
+declare const invalidBodyError: (data: unknown) => QueryError;
+
+interface SymfonyErrorTrace {
+    args: string[];
+    class: string;
+    file: string;
+    function: string;
+    line: number;
+    namespace: string;
+    short_class: string;
+    type: string;
+}
+interface SymfonyError {
+    class: string;
+    detail: string;
+    status: HttpStatusCode;
+    title: string;
+    trace: SymfonyErrorTrace[];
+    type: string;
+}
+
+declare const isSymfonyError: (error: unknown) => error is SymfonyError;
+declare const isSymfonyPagerfantaOutOfRangeError: (error: unknown) => error is SymfonyError;
+declare const isSymfonyFormViolationListError: (error: unknown) => error is FormViolationListView;
+declare const isSymfonyListError: (error: unknown) => error is FormViolationView[];
+
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthProvider, BooleanArrayQueryField, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, index_d as ExperimentalQuery, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, Query, QueryClient, QueryCreator, QueryDevtoolsComponent, QueryDirective, QueryError, QueryField, QueryForm, QueryShortNamePipe, QueryStateType, QueryStore, SearchQueryField, SortQueryField, StringArrayQueryField, addQueryContainerHandling, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, createInfinityQueryConfig, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, decryptBearer, deepFreeze, def, detectContentTypeHeader, effectComputed, extractExpiresInSeconds$1 as extractExpiresInSeconds, extractQuery, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getResponseUrl, gql, hasHeader, ignoreAutoRefresh, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mergeHeaders, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetPageOnError, serializeBody, shouldCacheQuery, shouldRetryRequest$1 as shouldRetryRequest, skipPaginationPageParamCalculator, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
+export type { AnyGqlQueryConfig, AnyInfinityQuery, AnyInfinityQueryConfig, AnyQuery, AnyQueryCollection, AnyQueryCollectionData, AnyQueryCollectionResponse, AnyQueryCreator, AnyQueryCreatorCollection, AnyQueryForm, AnyRestQueryConfig, AnyRoute, AppendItemsLocation, AuthProvider, AuthProviderBasicConfig, AuthProviderBearerConfig, AuthProviderCustomHeaderConfig, BaseArguments, BearerRefreshConfig, BuildQueryStringConfig, CacheAdapterFn$1 as CacheAdapterFn, Cancelled, ClassValidatorError, ConstructQuery, EmptyObject, EntityGetParams, EntityIdParams, EntityKey, EntitySetParams, EntityStoreConfig, ExecuteQueryOptions, Failure, GQL, GqlQueryConfig, GqlQueryConfigWithoutMethod, GqlTransferOption, InfinityQueryConfig, InfinityQueryConfigType, InfinityQueryOf, InfinityQueryParamLocation, InsertFromConfig, Loading, Method, OptionalQueryFieldOptions, PageParamCalculatorOptions, PartialXhrState, PathParams, PollConfig, Prepared, QueryArgsOf, QueryAutoRefreshConfig, QueryClientConfig, QueryClientDevtoolsOptions, QueryCollectionKeysOf, QueryCollectionOf, QueryCollectionWithNullableQuery, QueryConfig, QueryConfigBase, QueryConfigWithoutMethod, QueryContainerConfig, QueryDataOf, QueryEntityConfig, QueryFieldOptions, QueryFilterConfig, QueryFormGroup, QueryFormGroupControls, QueryFormObserveOptions, QueryFormOf, QueryFormOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions, QueryMockConfig, QueryOf, QueryParams, QueryPrepareFn, QueryResponseOf, QueryRouteOf, QueryState, QueryStateMeta, QueryStateResponseOf, QueryStateSignal, QueryStateSuccessMeta, QueryStoreIdOf, QueryStoreOf, QueryTrigger, RemoveFromConfig, RequestConfig, RequestError, RequestEvent, RequestHeaders, RequestHeadersMethodMap, RequestProgress, RequestRetryFn, RequestRetryFnConfig, RequestRetryFnResult, ResetPageOnErrorOperatorConfig, RestQueryConfig, RouteString, RouteType, Sort, SortDirection, Success, SymfonyError, SymfonyErrorTrace, TokenResponse, TotalPagesExtractorOptions, TransformedGqlQuery, WithBody, WithConfig, WithHeaders, WithInjector, WithMock, WithPathParams, WithQueryParams, WithVariables };