@ethlete/query 5.44.0 → 5.45.0

package/types/ethlete-query.d.ts

@@ -0,0 +1,3302 @@
+import { BehaviorSubject, Observable, Subscribable } from "rxjs";
+import { ContentfulGqlLikePaginated, DynLikePaginated, FormViolationListView, FormViolationView, GgLikePaginated, NormalizedPagination, Paginated } from "@ethlete/types";
+import { HttpClient, HttpContext, HttpErrorResponse, HttpEvent, HttpHeaders, HttpStatusCode } from "@angular/common/http";
+import * as i0 from "@angular/core";
+import { CreateComputedOptions, CreateEffectOptions, DestroyRef, EffectRef, EnvironmentInjector, ErrorHandler, InjectionToken, Injector, OnDestroy, OnInit, PipeTransform, Signal, TrackByFunction, WritableSignal, ɵEffectScheduler } from "@angular/core";
+import * as i1 from "@ethlete/core";
+import { RuntimeError } from "@ethlete/core";
+import { ToObservableOptions, ToSignalOptions } from "@angular/core/rxjs-interop";
+import { FormControl, FormGroup } from "@angular/forms";
+export type EntityKey = string | number;
+export interface EntityStoreConfig {
+  name: string;
+  logActions?: boolean;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export declare function mapToPaginated<T>(response: Paginated<T>): import("rxjs").OperatorFunction<unknown, Paginated<T>>;
+/**
+ * Use an other store to represent a property of the current entity.
+ */
+export 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>) => import("rxjs").OperatorFunction<OriginStoreType, ComputedEntityType | null>;
+/**
+ * Remove entities from a store based on a where function.
+ */
+export declare const removeFrom: <T>(store: EntityStore<T>, { where, id }: RemoveFromConfig<T>) => void;
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+export interface RequestError<Detail = unknown> {
+  url: string;
+  status: HttpStatusCode;
+  statusText: string;
+  detail: Detail;
+  httpErrorResponse: HttpErrorResponse;
+}
+export type RequestHeaders = Record<string, string>;
+export type QueryParams = object;
+export type PathParams = Record<string, string | number>;
+export type CacheAdapterFn = (headers: RequestHeaders) => number | null;
+export type RequestHeadersMethodMap = { [M in Method]?: RequestHeaders; };
+export interface PartialXhrState {
+  headers: RequestHeaders;
+  status: number;
+  statusText: string;
+  url: string;
+}
+export interface RequestRetryFnConfig {
+  error: RequestError;
+  headers: RequestHeaders;
+  currentRetryCount: number;
+}
+export interface RequestRetryFnResult {
+  retry: boolean;
+  delay?: number;
+}
+export type RequestRetryFn = (config: RequestRetryFnConfig) => RequestRetryFnResult;
+export interface RequestConfig {
+  method: Method;
+  urlWithParams: string;
+  body?: unknown;
+  reportProgress?: boolean;
+  withCredentials?: boolean;
+  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+  headers?: RequestHeaders;
+  cacheAdapter?: CacheAdapterFn;
+  retryFn?: RequestRetryFn;
+}
+export type RequestProgress = {
+  current: number;
+  percentage?: number;
+  total?: number;
+};
+export 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;
+};
+export 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>;
+}
+export declare const request: <Response = unknown>(config: RequestConfig) => Observable<RequestEvent<Response>>;
+export declare const isNaN: (value: unknown) => boolean;
+export declare const isEmptyString: (value: unknown) => boolean;
+export declare const isRequestError: <T = unknown>(error: unknown) => error is RequestError<T>;
+export declare const buildRoute: (options: {
+  base: string;
+  route: AnyRoute | null | undefined;
+  pathParams?: PathParams;
+  queryParams?: QueryParams;
+  queryParamConfig?: BuildQueryStringConfig;
+}) => string;
+export declare const buildQueryString: (params: QueryParams, config?: BuildQueryStringConfig) => string | null;
+export declare const extractExpiresInSeconds: (headers: RequestHeaders) => number | null;
+export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
+export declare const serializeBody: (body: unknown) => ArrayBuffer | URLSearchParams | Blob | FormData | string | null;
+export declare const transformMethod: (config: {
+  method: Method;
+  transferVia?: "GET" | "POST";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const detectContentTypeHeader: (body: unknown) => string | null;
+export declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
+export declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
+export declare const parseAllXhrResponseHeaders: (xhr: XMLHttpRequest) => RequestHeaders;
+export declare const getResponseUrl: (xhr: XMLHttpRequest) => string | null;
+export declare const shouldRetryRequest: 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 QueryFeatureType: {
+  readonly WITH_ARGS: "WITH_ARGS";
+  readonly WITH_LOGGING: "WITH_LOGGING";
+  readonly WITH_ERROR_HANDLING: "WITH_ERROR_HANDLING";
+  readonly WITH_SUCCESS_HANDLING: "WITH_SUCCESS_HANDLING";
+  readonly WITH_POLLING: "WITH_POLLING";
+  readonly WITH_AUTO_REFRESH: "WITH_AUTO_REFRESH";
+  readonly WITH_RESPONSE_UPDATE: "WITH_RESPONSE_UPDATE";
+};
+type QueryFeatureType = (typeof QueryFeatureType)[keyof typeof QueryFeatureType];
+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;
+};
+declare const createQueryFeature: <TArgs extends QueryArgs>(config: {
+  type: QueryFeatureType;
+  fn: QueryFeatureFn<TArgs>;
+}) => QueryFeature<TArgs>;
+/**
+ * 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) => import("@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$1: (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$1: (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 bindSignalToTarget: <T>(signal: Signal<T>, target: WritableSignal<T>) => EffectRef;
+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;
+/** Runs .unbind() if the DestroyRef.onDestroy() gets called */
+type DestroyCleanupCallback = () => void;
+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$1 = (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$1;
+  /**
+   * 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 | AnyNewQuery> = 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 AnyNewQuery = 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$1;
+  /**
+   * 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<AnyNewQuery, NormalizedPagination<unknown>>;
+type PagedQueryStack<TQuery extends AnyNewQuery, 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 QueryRuntimeErrorCode: {
+  readonly QUERY_FEATURE_USED_MULTIPLE_TIMES: 0;
+  readonly WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION: 100;
+  readonly WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 101;
+  readonly WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102;
+  readonly WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY: 103;
+  readonly SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT: 104;
+  readonly COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED: 200;
+  readonly ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG: 201;
+  readonly DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG: 202;
+  readonly LOGIN_CALLED_WITHOUT_CONFIG: 203;
+  readonly LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG: 204;
+  readonly REFRESH_TOKEN_CALLED_WITHOUT_CONFIG: 205;
+  readonly SELECT_ROLE_CALLED_WITHOUT_CONFIG: 206;
+  readonly DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT: 207;
+  readonly DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN: 208;
+  readonly DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN: 209;
+  readonly UNABLE_TO_DECRYPT_BEARER_TOKEN: 210;
+  readonly BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER: 211;
+  readonly UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM: 300;
+  readonly UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM: 301;
+  readonly PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES: 400;
+  readonly PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE: 401;
+  readonly PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE: 402;
+  readonly QUERY_STACK_WITH_ARGS_USED: 500;
+  readonly QUERY_STACK_WITH_RESPONSE_UPDATE_USED: 501;
+  readonly QUERY_STACK_TOTAL_QUERIES_AND_EXPECTED_QUERIES_MISMATCH: 502;
+};
+type QueryRuntimeErrorCode = (typeof QueryRuntimeErrorCode)[keyof typeof QueryRuntimeErrorCode];
+declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<0>;
+declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<100>;
+declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<101>;
+declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<102>;
+declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<103>;
+declare const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent: () => RuntimeError<104>;
+declare const cookieLoginTriedButCookieDisabled: () => RuntimeError<200>;
+declare const enableCookieCalledWithoutCookieConfig: () => RuntimeError<201>;
+declare const disableCookieCalledWithoutCookieConfig: () => RuntimeError<202>;
+declare const loginCalledWithoutConfig: () => RuntimeError<203>;
+declare const loginWithTokenCalledWithoutConfig: () => RuntimeError<204>;
+declare const refreshTokenCalledWithoutConfig: () => RuntimeError<205>;
+declare const selectRoleCalledWithoutConfig: () => RuntimeError<206>;
+declare const defaultResponseTransformerResponseNotObject: (currentType: string) => RuntimeError<207>;
+declare const defaultResponseTransformerResponseNotContainingAccessToken: () => RuntimeError<208>;
+declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<209>;
+declare const unableToDecryptBearerToken: (token: string) => RuntimeError<210>;
+declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<211>;
+declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<300>;
+declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<301>;
+declare const pagedQueryStackPageBiggerThanTotalPages: (page: number, totalPages: number) => RuntimeError<400>;
+declare const pagedQueryStackNextPageCalledWithoutPreviousPage: () => RuntimeError<401>;
+declare const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<402>;
+declare const queryStackWithArgsUsed: () => RuntimeError<500>;
+declare const queryStackWithResponseUpdateUsed: () => RuntimeError<501>;
+declare const queryStackTotalQueriesAndExpectedQueriesMismatch: (totalQueries: number, expectedQueries: number) => RuntimeError<502>;
+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 AnyNewQuery> = {
+  /** 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 AnyNewQuery, 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<AnyNewQuery, 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>;
+};
+export type TransformedGqlQuery = {
+  query: string;
+  variables?: string;
+  operationName?: string;
+};
+export declare const transformGql: (str: string) => (variables: Record<string, unknown> | null | undefined) => TransformedGqlQuery;
+export type GQL = string & {
+  gql: 'tag';
+};
+export 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 transformExecStateToQueryState: <TArgs extends QueryArgs>(execState: QueryExecutionState<TArgs> | null) => QueryState<ResponseType<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 AnyNewQuery> {
+  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;
+}
+export 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;
+}
+export interface QueryFilterConfig {
+  /**
+   * If `true`, the response will be cached until the next response is received or the query fails.
+   * @default false
+   */
+  cacheResponse?: boolean;
+}
+export declare const addQueryContainerHandling: (obs: Observable<AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null>, valueFn: () => AnyQuery | AnyQuery[] | AnyLegacyQuery | AnyLegacyQuery[] | null | undefined, config?: QueryContainerConfig) => void;
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+export 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>;
+export 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>;
+export declare function toQuerySignal<T extends AnyQuery | AnyLegacyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
+  initialValue?: undefined;
+  requireSync: true;
+} & QueryContainerConfig): Signal<T>;
+export 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>;
+export declare function effectComputed<T extends AnyQuery | AnyLegacyQuery | AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, injector: Injector): Signal<T>;
+export 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.
+ */
+export declare function queryComputedTillTruthy<T extends AnyQuery | AnyLegacyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
+export declare function queryArrayComputed<T extends AnyQuery[] | AnyLegacyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+export declare function toQuerySubject<T extends AnyQuery | AnyLegacyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
+export declare function queryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): import("@angular/core").WritableSignal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+export type QueryStateSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>> = Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null> & {
+  reset: () => void;
+};
+export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): QueryStateSignal<T>;
+export declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").RequestError<unknown> | null>;
+export declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").Loading | null>;
+export 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
+ */
+export 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>;
+};
+type 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 AnyNewQuery> = (args: Arguments & 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<LegacyArgumentsOfQueryArgs<TArgs>, Response, RouteType<LegacyArgumentsOfQueryArgs<TArgs>>, Store, Data, Id, Query$1<TArgs>>;
+  createSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgumentsOfQueryArgs<TArgs>, RouteType<LegacyArgumentsOfQueryArgs<TArgs>>, Store, Data, Id, Query$1<TArgs>> | null>;
+  createSignal: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<LegacyQuery<Response, LegacyArgumentsOfQueryArgs<TArgs>, RouteType<LegacyArgumentsOfQueryArgs<TArgs>>, Store, Data, Id, Query$1<TArgs>> | null>;
+  behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<LegacyQuery<Response, LegacyArgumentsOfQueryArgs<TArgs>, RouteType<LegacyArgumentsOfQueryArgs<TArgs>>, 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>;
+export 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";
+export 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.";
+export declare class ParseHttpErrorCodeToTitleDePipe implements PipeTransform {
+  transform: (statusCode: import("@angular/common/http").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: i0.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleDePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleDePipe, "parseHttpErrorCodeToTitleDe", true>;
+}
+export declare class ParseHttpErrorCodeToMessageDePipe implements PipeTransform {
+  transform: (statusCode: import("@angular/common/http").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: i0.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageDePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<ParseHttpErrorCodeToMessageDePipe, "parseHttpErrorCodeToMessageDe", true>;
+}
+export 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";
+export 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.";
+export declare class ParseHttpErrorCodeToTitleEnPipe implements PipeTransform {
+  transform: (statusCode: import("@angular/common/http").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: i0.ɵɵFactoryDeclaration<ParseHttpErrorCodeToTitleEnPipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<ParseHttpErrorCodeToTitleEnPipe, "parseHttpErrorCodeToTitleEn", true>;
+}
+export declare class ParseHttpErrorCodeToMessageEnPipe implements PipeTransform {
+  transform: (statusCode: import("@angular/common/http").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: i0.ɵɵFactoryDeclaration<ParseHttpErrorCodeToMessageEnPipe, never>;
+  static ɵpipe: i0.ɵɵ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>>;
+};
+declare namespace index_d_exports {
+  export { AnyBearerAuthProviderConfig, AnyLegacyQuery, AnyLegacyQueryCreator, AnyNewQuery, AnyPagedQueryStack, AnyQueryCreator$1 as AnyQueryCreator, AnyQuerySnapshot, AnyQueryStack, BearerAuthProvider$1 as BearerAuthProvider, BearerAuthProviderConfig, BearerAuthProviderCookieConfig, BearerAuthProviderRef, BearerAuthProviderRouteConfig, BearerAuthProviderTokens, BodyType, CLEAR_QUERY_ARGS, CacheAdapterFn$1 as CacheAdapterFn, CleanupPreviousExecuteOptions, ClearQueryArgs, CreateBearerAuthProviderConfigOptions, CreateGqlQueryCreatorOptions, CreateGqlQueryExecuteOptions, CreateGqlQueryOptions, CreateHttpRequestClientOptions, CreateHttpRequestDependencies, CreateHttpRequestOptions, CreateLegacyQueryCreatorOptions, CreateLegacyQueryOptions, CreatePagedQueryStackOptions, CreateQueryClientConfigOptions, CreateQueryCreatorOptions, CreateQueryExecuteOptions, CreateQueryObjectOptions, CreateQueryOptions, CreateQueryRepositoryConfig, CreateQuerySnapshotOptions, CreateQueryStackOptions, CreateSecureQueryExecuteOptions, CreateSecureQueryOptions, CreateWebSocketClientConfig, CreateWebSocketClientTransport, DestroyCleanupCallback, GqlQueryArgs, GqlQueryMethod, GqlQueryTransport, GqlVariablesType, HttpErrorEvent, HttpRequest, HttpRequestLoadingProgressState, HttpRequestLoadingState, HttpRequestResponseType, HttpRequestTransferCacheConfig, InternalCreateGqlQueryCreatorOptions, InternalCreateQueryCreatorOptions, InternalQueryExecute, InternalRunQueryExecuteOptions, InternalSecureCreateQueryCreatorOptions, InternalWebSocketRoom, LegacyArgumentsOfQueryArgs, LegacyQuery, LegacyQueryCreator, LegacyQueryPrepareFn, PagedQueryStack, PagedQueryStackDirection, PagedQueryStackExecuteOptions, PagedQueryStackResetOptions, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, PathParamsType, Query$1 as Query, QueryArgs, QueryArgsOf$1 as QueryArgsOf, QueryArgsOfLegacyArguments, QueryBase, QueryClient$1 as QueryClient, QueryClientConfig$1 as QueryClientConfig, QueryClientRef, QueryConfig$1 as QueryConfig, QueryCreator$1 as QueryCreator, QueryDependencies, QueryErrorResponse, QueryErrorResponseItem, QueryErrorResponseList, QueryErrorResponseSingle, QueryExecute, QueryExecuteArgs, QueryExecuteOptions, QueryExecuteState, QueryExecutionState, QueryExecutionStateFailure, QueryExecutionStateLoading, QueryExecutionStateLoadingWithCachedResponse, QueryExecutionStateLoadingWithNoResponse, QueryExecutionStateSuccess, QueryFeature, QueryFeatureContext, QueryFeatureFlags, QueryFeatureFn, QueryFeatureType, QueryKey, QueryKeyNoCache, QueryKeyOrNone, QueryMethod, QueryParamsType, QueryRepository, QueryRepositoryDependencies, QueryRepositoryItem, QueryRepositoryRequestOptions, QueryRuntimeErrorCode, QuerySnapshot, QueryStack, QueryStackSubtle, QueryState$1 as QueryState, QueryStateSubtle, QuerySubtle, ReadonlyQuery, RequestArgs, ResetExecuteStateOptions, ResponseType, RouteString$1 as RouteString, RouteType$1 as RouteType, RunQueryCreator, RunQueryExecuteOptions, SPEED_BUFFER_TIME_IN_MS, SetupQueryDependenciesOptions, SetupQueryStateOptions, ShouldRetryRequestFn, ShouldRetryRequestOptions, ShouldRetryRequestResult, SocketMessageView, WebSocketClient, WebSocketClientConfig, WebSocketClientRef, WebSocketClientSubtle, WebSocketRoom, WithAutoRefreshFeatureOptions, WithErrorHandlingFeatureOptions, WithLegacyConfig, WithLoggingFeatureOptions, WithPollingFeatureOptions, WithResponseUpdateFeatureFnData, WithResponseUpdateFeatureOptions, WithSuccessHandlingFeatureOptions, applyQueryFeatures, bearerExpiresInPropertyNotNumber, bindSignalToTarget, buildQueryCacheKey$1 as buildQueryCacheKey, circularQueryDependencyChecker, cleanupPreviousExecute, contentfulGqlLikePaginationAdapter, cookieLoginTriedButCookieDisabled, createBearerAuthProvider, createBearerAuthProviderConfig, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryClientConfig, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFn, createSecureGetQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createWebSocketClient, createWebSocketClientConfig, defaultResponseTransformerResponseNotContainingAccessToken, defaultResponseTransformerResponseNotContainingRefreshToken, defaultResponseTransformerResponseNotObject, disableCookieCalledWithoutCookieConfig, dynLikePaginationAdapter, enableCookieCalledWithoutCookieConfig, ethletePaginationAdapter, extractExpiresInSeconds$1 as extractExpiresInSeconds, fakePaginationAdapter, getQueryFeatureUsage, ggLikePaginationAdapter, isCreateGqlQueryOptions, isLegacyQuery, loginCalledWithoutConfig, loginWithTokenCalledWithoutConfig, maybeExecute, nestedEffect, normalizeQueryRepositoryKey, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, provideBearerAuthProvider, provideQueryClient, provideWebSocketClient, queryExecute, queryFeatureUsedMultipleTimes, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, refreshTokenCalledWithoutConfig, resetExecuteState, selectRoleCalledWithoutConfig, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery$1 as shouldCacheQuery, shouldRetryRequest$1 as shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, splitQueryConfig, transformArrayResponse, transformExecStateToQueryState, transformPaginatedResponse, unableToDecryptBearerToken, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withLogging, withPolling, withPollingUsedOnUnsupportedHttpMethod, withResponseUpdate, withSuccessHandling };
+}
+export 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;
+}
+export type OptionalQueryFieldOptions<T = string> = Partial<QueryFieldOptions<T>>;
+export type QueryFormGroupControls<T extends Record<string, QueryField<any>>> = { [Property in keyof T]: T[Property]['control']; };
+export type QueryFormValue<T extends Record<string, QueryField<any>>> = { [Property in keyof T]: T[Property]['control']['value']; };
+export type QueryFormOf<T extends FormGroup> = { [K in keyof T['controls']]: QueryField<T['controls'][K]['value']>; };
+export interface QueryFormGroup extends FormGroup {
+  _setValue: FormGroup['setValue'];
+  _patchValue: FormGroup['patchValue'];
+  setValue(value: unknown, options?: QueryFormWriteOptions): void;
+  patchValue(value: unknown, options?: QueryFormWriteOptions): void;
+}
+export 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;
+}
+export interface QueryFormValueEvent<T extends Record<string, QueryField<any>>> {
+  previousValue: QueryFormValue<T> | null;
+  currentValue: QueryFormValue<T>;
+}
+export 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;
+}
+export declare const transformToString: (value: unknown) => string | null;
+export declare const transformToStringArray: (value: unknown) => string[] | null;
+export declare const transformToNumber: (value: unknown) => number | null;
+export declare const transformToNumberArray: (value: unknown) => number[] | null;
+export declare const transformToBoolean: (value: unknown) => boolean | null;
+export declare const transformToBooleanArray: (value: unknown) => boolean[] | null;
+export declare const transformToDate: (value: unknown) => Date | null;
+export declare const transformToDateArray: (value: unknown) => Date[] | null;
+export type SortDirection = 'asc' | 'desc' | '';
+export interface Sort {
+  active: string;
+  direction: SortDirection;
+}
+export declare const transformToSort: (value: unknown) => Sort | null;
+export declare const transformToSortQueryParam: (value: unknown) => string | null;
+export declare class QueryField<T> {
+  data: QueryFieldOptions<T>;
+  get control(): FormControl<T | null>;
+  constructor(data: QueryFieldOptions<T>);
+}
+export declare class SearchQueryField {
+  _data?: OptionalQueryFieldOptions<string | null> | undefined;
+  get control(): FormControl<string | null>;
+  data: QueryFieldOptions<string | null>;
+  constructor(_data?: OptionalQueryFieldOptions<string | null> | undefined);
+}
+export declare class SortQueryField {
+  _data?: OptionalQueryFieldOptions<Sort | null> | undefined;
+  get control(): FormControl<Sort | null>;
+  data: QueryFieldOptions<Sort | null>;
+  constructor(_data?: OptionalQueryFieldOptions<Sort | null> | undefined);
+}
+export 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);
+}
+export declare class BooleanArrayQueryField {
+  _data?: OptionalQueryFieldOptions<boolean[] | null> | undefined;
+  get control(): FormControl<boolean[] | null>;
+  data: QueryFieldOptions<boolean[] | null>;
+  constructor(_data?: OptionalQueryFieldOptions<boolean[] | null> | undefined);
+}
+export declare class NumberArrayQueryField {
+  _data?: OptionalQueryFieldOptions<number[] | null> | undefined;
+  get control(): FormControl<number[] | null>;
+  data: QueryFieldOptions<number[] | null>;
+  constructor(_data?: OptionalQueryFieldOptions<number[] | null> | undefined);
+}
+export declare class DateQueryField {
+  _data?: OptionalQueryFieldOptions<Date | null> | undefined;
+  get control(): FormControl<Date | null>;
+  data: QueryFieldOptions<Date | null>;
+  constructor(_data?: OptionalQueryFieldOptions<Date | null> | undefined);
+}
+export declare class DateArrayQueryField {
+  _data?: OptionalQueryFieldOptions<Date[] | null> | undefined;
+  get control(): FormControl<Date[] | null>;
+  data: QueryFieldOptions<Date[] | null>;
+  constructor(_data?: OptionalQueryFieldOptions<Date[] | null> | undefined);
+}
+export 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);
+}
+export type AnyQueryForm = QueryForm<any>;
+export 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$: import("rxjs").Observable<QueryFormValueEvent<T>>;
+  readonly currentValue$: import("rxjs").Observable<QueryFormValue<T>>;
+  readonly previousValue$: import("rxjs").Observable<QueryFormValue<T> | null>;
+  readonly changes: import("@angular/core").Signal<QueryFormValueEvent<T> | undefined>;
+  readonly currentValue: import("@angular/core").Signal<QueryFormValue<T> | undefined>;
+  readonly previousValue: import("@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$: import("rxjs").Observable<number>;
+  get controls(): 0 extends 1 & QueryFormGroupControls<T> ? {
+    [key: string]: import("@angular/forms").AbstractControl<any, 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export interface EntityIdParams<Response, Arguments> {
+  /**
+   * The response data.
+   */
+  response: Response;
+  /**
+   * The arguments passed to the query.
+   */
+  args: Arguments;
+}
+export 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;
+}
+export 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>;
+};
+export 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;
+};
+export type GqlTransferOption = 'GET' | 'POST';
+export 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;
+}
+export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any, any>;
+export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any, any>;
+export 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'>;
+export 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'>;
+export type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams & WithMock<unknown>;
+export interface WithHeaders {
+  /**
+   * The headers to send with the query.
+   */
+  headers?: Record<string, string>;
+}
+export 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;
+}
+export interface WithMock<MockResponse> {
+  mock?: QueryMockConfig<MockResponse>;
+}
+export 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;
+}
+export interface WithConfig {
+  /**
+   * Additional configuration for this query.
+   */
+  config?: QueryConfig;
+}
+export interface WithInjector {
+  injector?: Injector;
+}
+export interface WithVariables {
+  /**
+   * The variables for the query. (graphql only)
+   */
+  variables?: Record<string, unknown>;
+}
+export interface WithBody {
+  /**
+   * The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
+   */
+  body?: unknown;
+}
+export interface WithQueryParams {
+  /**
+   * The query parameters for the query. (after the ? in the url)
+   */
+  queryParams?: QueryParams;
+}
+export interface WithPathParams {
+  /**
+   * The path parameters for the query. (in front of the ? in the url)
+   */
+  pathParams?: PathParams;
+}
+export type QueryTrigger = 'program' | 'poll' | 'auto';
+export type EmptyObject = {};
+export 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;
+}
+export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
+  pathParams: infer PathParams;
+} ? (p: PathParams) => RouteString : RouteString;
+export type RouteString = `/${string}`;
+export type AnyRoute = ((p: PathParams) => string) | RouteString;
+export 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;
+}
+export declare const enum QueryStateType {
+  Prepared = "PREPARED",
+  Loading = "LOADING",
+  Success = "SUCCESS",
+  Failure = "FAILURE",
+  Cancelled = "CANCELLED"
+}
+export interface Prepared {
+  type: QueryStateType.Prepared;
+  meta: QueryStateMeta;
+}
+export interface Success<Response = unknown> {
+  type: QueryStateType.Success;
+  response: Response;
+  headers: RequestHeaders;
+  meta: QueryStateSuccessMeta;
+}
+export interface Failure {
+  type: QueryStateType.Failure;
+  error: RequestError;
+  meta: QueryStateMeta;
+}
+export interface Loading {
+  type: QueryStateType.Loading;
+  meta: QueryStateMeta;
+  partialText?: string;
+  progress?: RequestProgress;
+}
+export interface Cancelled {
+  type: QueryStateType.Cancelled;
+  meta: QueryStateMeta;
+}
+export interface QueryStateMeta {
+  id: number;
+  triggeredVia: QueryTrigger;
+  isWaitingForRetry?: boolean;
+  retryNumber?: number;
+  retryDelay?: number;
+}
+export interface QueryStateSuccessMeta extends QueryStateMeta {
+  expiresAt?: number;
+}
+export type QueryState<Response = unknown> = Loading | Success<Response> | Failure | Cancelled | Prepared;
+export type QueryStateResponseOf<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
+export type AnyQuery = Query<any, any, any, any, any, any>;
+export type AnyQueryCreatorCollection = {
+  [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
+};
+export type QueryCollectionOf<T extends {
+  [name: string]: AnyQueryCreator | AnyLegacyQueryCreator;
+}> = { [K in keyof T]: {
+  type: K;
+  query: ConstructQuery<T[K]>;
+}; }[keyof T];
+export type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
+export type QueryOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyLegacyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
+export type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;
+export type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;
+export type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyLegacyQuery | AnyQuery | null> = T extends AnyQueryCollection ? T['type'] : never;
+export type QueryCollectionWithNullableQuery<T extends AnyQueryCollection | null> = T extends null ? never : { [K in keyof T]: T[K] extends string ? T[K] : T[K] | null; };
+export 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;
+}
+export 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 _memoizedState$;
+  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;
+export declare function filterSuccess(): <T extends QueryState | null, Response extends QueryStateResponseOf<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response>>;
+export declare function ignoreAutoRefresh(): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+export declare function filterFailure(): <T extends QueryState | null>(source: Observable<T>) => Observable<Failure>;
+export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+export declare function takeUntilResponse(config?: {
+  excludeNull?: boolean;
+}): <T extends QueryState | null>(source: Observable<T>) => Observable<T>;
+export declare function filterNull(): <T>(source: Observable<T>) => Observable<OmitNull<T>>;
+export declare function switchQueryState(): <T extends AnyQuery | AnyLegacyQuery | null, Data extends QueryDataOf<T>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
+export declare function switchQueryCollectionState(): <T extends AnyQueryCollection | null, Data extends AnyQueryCollectionData<OmitNull<T>>>(source: Observable<T>) => Observable<QueryState<Data> | null>;
+export declare const resetPageOnError: <T extends AnyQuery | AnyLegacyQuery | null | undefined, J extends QueryForm<any>>(config: ResetPageOnErrorOperatorConfig<J>) => (source: Observable<T>) => Observable<QueryState<any> | T>;
+export declare const isQueryStateLoading: (state: QueryState | null | undefined) => state is Loading;
+export declare const isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success;
+export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
+export declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
+export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
+export declare const isAutoRefresh: (state: QueryState | null | undefined) => boolean;
+export declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
+export 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>;
+export declare const isQuery: <T extends AnyQuery | AnyLegacyQuery>(query: unknown) => query is T;
+export declare const isQueryCollection: <T extends AnyQueryCollection>(query: unknown) => query is T;
+/**
+ * @deprecated Use `createQueryCollectionSubject` instead. Will be removed in v6.
+ */
+export declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T) => BehaviorSubject<R | null>;
+export declare const createQueryCollectionSubject: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => BehaviorSubject<R | null>;
+export declare const createQueryCollectionSignal: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<T>>(queryMap: T, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<R | null>;
+export declare const extractQuery: <T extends AnyQuery | AnyLegacyQuery | AnyQueryCollection | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any, any> | (T & AnyLegacyQuery) | LegacyQuery<any, LegacyArgumentsOfQueryArgs<any>, `/${string}`, any, any, any, Query$1<any>> | null;
+export declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
+export 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>;
+export declare const computeQueryMethod: (config: {
+  config: AnyRestQueryConfig | AnyGqlQueryConfig;
+  client: QueryClient;
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const computeQueryBody: (config: {
+  config: AnyRestQueryConfig | AnyGqlQueryConfig;
+  client: QueryClient;
+  method: Method;
+  args?: BaseArguments;
+}) => unknown;
+export declare const computeQueryAuthHeader: (config: {
+  config: AnyRestQueryConfig | AnyGqlQueryConfig;
+  client: QueryClient;
+}) => Record<string, string> | null;
+export declare const computeQueryHeaders: (config: {
+  config: AnyRestQueryConfig | AnyGqlQueryConfig;
+  client: QueryClient;
+  args?: BaseArguments;
+}) => RequestHeaders | undefined;
+export declare const computeQueryQueryParams: (config: {
+  config: AnyRestQueryConfig | AnyGqlQueryConfig;
+  client: QueryClient;
+  args?: BaseArguments;
+}) => object | undefined;
+export 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;
+export 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;
+    /**
+     * 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;
+}
+export declare class QueryClient {
+  private _clientConfig;
+  get config(): QueryClientConfig;
+  get authProvider(): AuthProvider | null;
+  get authProvider$(): import("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;
+}
+export declare const shouldCacheQuery: (method: Method) => method is "GET" | "HEAD" | "OPTIONS" | "GQL_QUERY";
+export declare const buildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;
+export declare class QueryStore {
+  private _config?;
+  private _garbageCollector;
+  private _isInLowResourceMode;
+  private _lastBlurTimestamp;
+  private _storeChange$;
+  private _queryCreated$;
+  readonly storeChange$: import("rxjs").Observable<string>;
+  readonly queryCreated$: import("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;
+}
+export 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>;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
+export 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;
+export 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;
+export 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;
+export 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;
+export 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;
+export 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;
+export type ConstructQuery<T extends AnyQueryCreator | AnyLegacyQueryCreator> = ReturnType<T['prepare']>;
+export 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) => import("@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>;
+}
+export 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>;
+}
+export interface AuthProviderBasicConfig {
+  /**
+   * Basic auth username
+   */
+  username: string;
+  /**
+   * Basic auth password
+   */
+  password: string;
+}
+export interface AuthProviderCustomHeaderConfig {
+  /**
+   * The custom header name
+   * @example `X-Api-Key`
+   */
+  name: string;
+  /**
+   * The custom header value
+   * @example `myApiKey`
+   */
+  value: string;
+}
+export interface AuthProviderBearerConfig<T extends AnyQueryCreator> {
+  /**
+   * The initial jwt
+   */
+  token?: string;
+  /**
+   * Refresh token configuration
+   */
+  refreshConfig?: BearerRefreshConfig<T>;
+}
+export 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;
+}
+export declare const enum AuthBearerRefreshStrategy {
+  /**
+   * Automatically refresh the token 5 minutes before expiration.
+   * The time can be configured with the `refreshBuffer` property.
+   */
+  BeforeExpiration = "beforeExpiration"
+}
+export 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;
+}
+export declare class CustomHeaderAuthProvider implements AuthProvider {
+  _config: AuthProviderCustomHeaderConfig;
+  get header(): {
+    [x: string]: string;
+  };
+  constructor(_config: AuthProviderCustomHeaderConfig);
+  cleanUp(): void;
+}
+export declare class BasicAuthProvider implements AuthProvider {
+  _config: AuthProviderBasicConfig;
+  get header(): {
+    Authorization: string;
+  };
+  private get _basicAuthString();
+  constructor(_config: AuthProviderBasicConfig);
+  cleanUp(): void;
+}
+export 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$(): import("rxjs").Observable<TokenResponse>;
+  get tokens(): TokenResponse;
+  get currentRefreshQuery$(): import("rxjs").Observable<ConstructQuery<T> | null>;
+  get currentRefreshQuery(): ConstructQuery<T> | null;
+  get shouldRefreshOnUnauthorizedResponse(): boolean;
+  constructor(_config: AuthProviderBearerConfig<T>);
+  cleanUp(): void;
+  enableCookie(): void;
+  disableCookie(): void;
+  forceRefresh(): import("@ethlete/query").Query<any, any, any, any, any, any> | undefined;
+  private _setCookie;
+  private _deleteCookie;
+  private _prepareForRefresh;
+}
+export declare const isBasicAuthProvider: (authProvider: AuthProvider) => authProvider is BasicAuthProvider;
+export declare const isBearerAuthProvider: <T extends AnyQueryCreator>(authProvider: AuthProvider) => authProvider is BearerAuthProvider<T>;
+export declare const isCustomHeaderAuthProvider: (authProvider: AuthProvider) => authProvider is CustomHeaderAuthProvider;
+export declare const decryptBearer: <Result = Record<string, unknown>>(token: string) => Result | null;
+export interface ClassValidatorError {
+  statusCode: HttpStatusCode;
+  message: string[];
+  error: string;
+}
+export declare const isClassValidatorError: (error: unknown) => error is ClassValidatorError;
+export interface QueryClientDevtoolsOptions {
+  displayName?: string;
+  client: QueryClient;
+}
+export declare const QUERY_CLIENT_DEVTOOLS_TOKEN: InjectionToken<QueryClientDevtoolsOptions[]>;
+export 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';
+export declare class QueryDevtoolsComponent {
+  private readonly _cdr;
+  protected readonly _destroy$: import("rxjs").Observable<boolean>;
+  protected readonly queryClientConfigs: QueryClientDevtoolsOptions[];
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isTranslucent: import("@angular/core").WritableSignal<boolean>;
+  protected readonly snapLayout: import("@angular/core").WritableSignal<QueryDevtoolsSnapLayout>;
+  protected readonly queryListMode: import("@angular/core").WritableSignal<QueryListMode>;
+  protected readonly viewMode: import("@angular/core").WritableSignal<QueryViewMode>;
+  protected showResponse: import("@angular/core").WritableSignal<boolean>;
+  protected showRawResponse: import("@angular/core").WritableSignal<boolean>;
+  protected showQueryConfig: import("@angular/core").WritableSignal<boolean>;
+  protected showEntityStoreValue: import("@angular/core").WritableSignal<boolean>;
+  protected showArguments: import("@angular/core").WritableSignal<boolean>;
+  protected selectedClientIdCtrl: FormControl<number | null>;
+  protected readonly selectedClientId: import("@angular/core").Signal<number | null | undefined>;
+  protected readonly selectedQueryId: import("@angular/core").WritableSignal<number | null>;
+  protected readonly selectedClientConfig: import("@angular/core").Signal<QueryClientDevtoolsOptions>;
+  protected readonly queryStore: import("@angular/core").Signal<import("@ethlete/query").QueryStore>;
+  protected readonly queryStore$: import("rxjs").Observable<import("@ethlete/query").QueryStore>;
+  private readonly _queries$;
+  protected readonly queries: import("@angular/core").Signal<AnyQuery[] | undefined>;
+  protected readonly selectedQuery: import("@angular/core").Signal<AnyQuery | null>;
+  protected readonly selectedQuery$: import("rxjs").Observable<AnyQuery | null>;
+  protected selectedQueryEntityStore: import("@angular/core").Signal<EntityStore<unknown> | null>;
+  protected readonly selectedQueryEntityStore$: import("rxjs").Observable<EntityStore<unknown> | null>;
+  protected readonly selectedQueryEntityStoreValue$: import("rxjs").Observable<Record<string, unknown> | null>;
+  protected readonly queryHistory$: BehaviorSubject<AnyQuery[]>;
+  protected readonly stringifiedQueryConfig: import("@angular/core").Signal<{
+    query: string;
+    transferVia: import("@ethlete/query").GqlTransferOption | undefined;
+    method: import("@ethlete/query").Method;
+    secure: boolean | undefined;
+    route: any;
+    reportProgress: boolean | undefined;
+    responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
+    withCredentials: boolean | undefined;
+    autoRefreshOn: import("@ethlete/query").QueryAutoRefreshConfig | undefined;
+    enableSmartPolling: boolean | undefined;
+    hasEntityStore: boolean;
+  } | {
+    method: import("@ethlete/query").Method;
+    secure: boolean | undefined;
+    route: any;
+    reportProgress: boolean | undefined;
+    responseType: "arraybuffer" | "blob" | "json" | "text" | undefined;
+    withCredentials: boolean | undefined;
+    autoRefreshOn: import("@ethlete/query").QueryAutoRefreshConfig | undefined;
+    enableSmartPolling: boolean | undefined;
+    hasEntityStore: boolean;
+  } | null>;
+  protected readonly authProvider: import("@angular/core").Signal<import("@ethlete/query").AuthProvider | null | undefined>;
+  protected readonly authProviderDetails: import("@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: import("@ethlete/query").BearerAuthProvider<import("@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: import("@ethlete/query").AuthBearerRefreshStrategy | "AuthBearerRefreshStrategy.BeforeExpiration (default)";
+        readonly requestArgsAdapter: "default" | "custom";
+        readonly responseAdapter: "default" | "custom";
+      };
+      readonly name?: undefined;
+      readonly value?: undefined;
+      readonly username?: undefined;
+      readonly password?: undefined;
+    };
+  } | {
+    readonly type: "UnknownAuthProvider";
+    readonly header: () => Record<string, string>;
+    readonly provider: import("@ethlete/query").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: i0.ɵɵFactoryDeclaration<QueryDevtoolsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<QueryDevtoolsComponent, "et-query-devtools", never, {}, {}, never, never, true, never>;
+}
+export declare class QueryShortNamePipe implements PipeTransform {
+  transform(value: AnyQuery): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<QueryShortNamePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<QueryShortNamePipe, "queryShortName", true>;
+}
+export type QueryDirectiveContext<Q extends QueryDirectiveType | 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;
+};
+export type QueryDirectiveType = AnyQuery | AnyLegacyQuery | AnyQueryCollection;
+export declare class QueryDirective<Q extends QueryDirectiveType | null> {
+  private errorHandler;
+  private cdr;
+  private readonly _viewContext;
+  query: import("@angular/core").InputSignal<Q>;
+  cache: import("@angular/core").InputSignal<boolean>;
+  queryState: import("@angular/core").WritableSignal<import("@ethlete/query").QueryState<QueryDataOf<QueryOf<Q>>> | null>;
+  static ngTemplateContextGuard<Q extends QueryDirectiveType | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryDirectiveContext<Q>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, {
+    "query": {
+      "alias": "etQuery";
+      "required": true;
+      "isSignal": true;
+    };
+    "cache": {
+      "alias": "etQueryCache";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+export type AppendItemsLocation = 'start' | 'end';
+export interface PageParamCalculatorOptions {
+  page: number;
+  totalPages: number | null;
+  itemsPerPage: number;
+}
+export interface TotalPagesExtractorOptions<Arguments extends BaseArguments | undefined, QueryResponse> {
+  response: QueryResponse;
+  itemsPerPage: number;
+  args: Arguments;
+}
+export 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;
+  /**
+   * Enables or disables the infinite query functionality.
+   * @default true
+   */
+  enabled?: boolean;
+  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;
+export type AnyInfinityQueryConfig = InfinityQueryConfig<any, any, any, any>;
+export type AnyInfinityQuery = InfinityQuery<any, any, any, any, any>;
+export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator | AnyLegacyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryDataOf<QueryCreator>, InfinityResponse>;
+export 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']>;
+export 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;
+}
+export 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>;
+export declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;
+interface InfinityQueryContext<Q extends InfinityQueryConfig<DirectiveQueryCreator, 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;
+}
+export declare const INFINITY_QUERY_TOKEN: InjectionToken<InfinityQueryDirective<any>>;
+type DirectiveQueryCreator = AnyQueryCreator | AnyLegacyQueryCreator;
+export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<DirectiveQueryCreator, 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$(): import("rxjs").Observable<Q["response"]["arrayType"]>;
+  data: import("@angular/core").Signal<Q["response"]["arrayType"]>;
+  static ngTemplateContextGuard<Q extends InfinityQueryConfig<DirectiveQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
+  constructor();
+  private _setupInfinityQuery;
+  loadNextPage(): void;
+  reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
+  private _cleanup;
+  static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[etInfinityQuery]", ["etInfinityQuery"], {
+    "infinityQuery": {
+      "alias": "etInfinityQuery";
+      "required": false;
+    };
+  }, {}, never, never, true, [{
+    directive: typeof i1.DelayableDirective;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy {
+  private _elementRef;
+  private _infinityQuery;
+  private _destroy;
+  private _observer;
+  click$: import("rxjs").Observable<unknown>;
+  scrollContainerSelector: string | null;
+  infinityQueryOverride: import("@angular/core").InputSignal<InfinityQueryDirective<any> | null>;
+  infinityQuery: import("@angular/core").Signal<InfinityQueryDirective<any>>;
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  private _setupIntersectionObserver;
+  static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[etInfinityQueryTrigger], et-infinity-query-trigger", never, {
+    "scrollContainerSelector": {
+      "alias": "scrollContainerSelector";
+      "required": false;
+    };
+    "infinityQueryOverride": {
+      "alias": "infinityQueryOverride";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const buildErrorMessage: (code: string, message: string) => string;
+export declare class QueryError extends Error {
+  data?: unknown;
+  constructor(code: string, message: string, data?: unknown);
+}
+export declare const invalidBaseRouteError: (data: unknown) => QueryError;
+export declare const invalidRouteError: (data: unknown) => QueryError;
+export declare const pathParamsMissingInRouteFunctionError: (data: unknown) => QueryError;
+export declare const queryStateAlreadyHasKeyError: (data: unknown) => QueryError;
+export declare const queryStateDoesNotContainKeyError: (data: unknown) => QueryError;
+export declare const queryStateCannotTransformError: (data: unknown) => QueryError;
+export declare const invalidBodyError: (data: unknown) => QueryError;
+export interface SymfonyErrorTrace {
+  args: string[];
+  class: string;
+  file: string;
+  function: string;
+  line: number;
+  namespace: string;
+  short_class: string;
+  type: string;
+}
+export interface SymfonyError {
+  class: string;
+  detail: string;
+  status: HttpStatusCode;
+  title: string;
+  trace: SymfonyErrorTrace[];
+  type: string;
+}
+export declare const isSymfonyError: (error: unknown) => error is SymfonyError;
+export declare const isSymfonyPagerfantaOutOfRangeError: (error: unknown) => error is SymfonyError;
+export declare const isSymfonyFormViolationListError: (error: unknown) => error is FormViolationListView;
+export declare const isSymfonyListError: (error: unknown) => error is FormViolationView[];
+export { index_d_exports as ExperimentalQuery };