@ethlete/query 5.19.0 → 5.20.1

package/lib/experimental/http-request.d.ts

@@ -1,30 +1,80 @@
-import { HttpClient, HttpContext, HttpErrorResponse, HttpEvent, HttpHeaders } from '@angular/common/http';
+import { HttpClient, HttpContext, HttpErrorResponse, HttpEvent } from '@angular/common/http';
 import { Signal } from '@angular/core';
-import { BodyType, PathParamsType, QueryArgs, QueryParamsType, ResponseType } from './query';
+import { QueryArgs, RequestArgs, ResponseType } from './query';
 import { CacheAdapterFn } from './query-client-config';
 import { QueryMethod } from './query-creator';
 import { ShouldRetryRequestFn } from './query-utils';
 export declare const SPEED_BUFFER_TIME_IN_MS = 2000;
-export type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
-    method: QueryMethod;
-    fullPath: string;
-    pathParams?: PathParamsType<TArgs>;
-    queryParams?: QueryParamsType<TArgs>;
-    body?: BodyType<TArgs>;
+export type HttpRequestTransferCacheConfig = boolean | {
+    includeHeaders?: string[];
+};
+export type HttpRequestResponseType = 'json' | 'text' | 'blob' | 'arraybuffer';
+export type CreateHttpRequestDependencies = {
+    /** The http client instance to use for the request */
+    httpClient: HttpClient;
+};
+export 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;
-    transferCache?: boolean | {
-        includeHeaders?: string[];
-    };
-    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    /**
+     * 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;
-    headers?: HttpHeaders;
-    httpClient: HttpClient;
+};
+export 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: CreateHttpRequestDependencies;
+    /** The client options of the request */
+    clientOptions?: CreateHttpRequestClientOptions;
+    /**
+     * The cache adapter function to use for the request
+     * @default extractExpiresInSeconds()
+     */
     cacheAdapter?: CacheAdapterFn;
+    /**
+     * The retry function to use for the request
+     * @default shouldRetryRequest()
+     */
     retryFn?: ShouldRetryRequestFn;
 };
 export 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;
 };
 export type HttpRequestLoadingProgressState = {
@@ -40,14 +90,22 @@ export type HttpRequestLoadingProgressState = {
     remainingTime: number | null;
 };
 export type HttpRequest<TArgs extends QueryArgs> = {
+    /** Executes the request */
     execute: () => 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<HttpErrorResponse | 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 */
 export type HttpErrorEvent = {
     type: 'error';
     error: HttpErrorResponse;

package/lib/experimental/index.d.ts

@@ -13,6 +13,7 @@ export * from './query-execute-utils';
 export * from './query-features';
 export * from './query-repository';
 export * from './query-snapshot';
+export * from './query-stack';
 export * from './query-state';
 export * from './query-utils';
 export * from './secure-query';

package/lib/experimental/query-dependencies.d.ts

@@ -1,4 +1,4 @@
-import { DestroyRef, Injector } from '@angular/core';
+import { DestroyRef, EnvironmentInjector } from '@angular/core';
 import { QueryClient } from './query-client';
 import { QueryClientConfig } from './query-client-config';
 export type SetupQueryDependenciesOptions = {
@@ -7,6 +7,6 @@ export type SetupQueryDependenciesOptions = {
 export type QueryDependencies = {
     destroyRef: DestroyRef;
     client: QueryClient;
-    injector: Injector;
+    injector: EnvironmentInjector;
 };
 export declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;

package/lib/experimental/query-errors.d.ts

@@ -18,7 +18,9 @@ export declare const enum RuntimeErrorCode {
     DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN = 208,
     DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN = 209,
     UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,
-    BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211
+    BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,
+    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM = 300,
+    UNCACHEABLE_REQUEST_HAS_SKIP_CACHE_PARAM = 301
 }
 export declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<RuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
 export declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<RuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
@@ -37,3 +39,5 @@ export declare const defaultResponseTransformerResponseNotContainingAccessToken:
 export declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN>;
 export declare const unableToDecryptBearerToken: (token: string) => RuntimeError<RuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
 export declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<RuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;
+export declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM>;
+export declare const uncacheableRequestHasSkipCacheParam: () => RuntimeError<RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_SKIP_CACHE_PARAM>;

package/lib/experimental/query-execute-utils.d.ts

@@ -1,4 +1,4 @@
-import { EffectRef } from '@angular/core';
+import { EffectRef, WritableSignal } from '@angular/core';
 import { QueryArgs, RequestArgs } from './query';
 import { CreateQueryExecuteOptions } from './query-execute';
 export type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
@@ -8,13 +8,21 @@ export type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
 export declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
 export type QueryExecuteState = {
     effectRefs: EffectRef[];
-    previousKey: string | false;
+    previousKey: WritableSignal<string | false>;
 };
 export declare const setupQueryExecuteState: () => QueryExecuteState;
+export type RunQueryExecuteOptions = {
+    skipCache?: boolean;
+};
 export type QueryExecuteOptions<TArgs extends QueryArgs> = {
     executeOptions: CreateQueryExecuteOptions<TArgs>;
     executeState: QueryExecuteState;
-    args?: RequestArgs<TArgs> | null;
+    args: RequestArgs<TArgs> | null;
+    options?: RunQueryExecuteOptions;
 };
 export declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
-export declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+export type CleanupPreviousExecuteOptions<TArgs extends QueryArgs> = {
+    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeState: QueryExecuteState;
+};
+export declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: CleanupPreviousExecuteOptions<TArgs>) => void;

package/lib/experimental/query-execute.d.ts

@@ -1,6 +1,8 @@
+import { Signal } from '@angular/core';
 import { QueryArgs, RequestArgs } from './query';
 import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
 import { QueryDependencies } from './query-dependencies';
+import { RunQueryExecuteOptions } from './query-execute-utils';
 import { QueryState } from './query-state';
 export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
     deps: QueryDependencies;
@@ -9,8 +11,13 @@ export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
     creatorInternals: InternalCreateQueryCreatorOptions;
     queryConfig: QueryConfig;
 };
+export type QueryExecuteArgs<TArgs extends QueryArgs> = {
+    args?: RequestArgs<TArgs> | null;
+    options?: RunQueryExecuteOptions;
+};
 export type QueryExecute<TArgs extends QueryArgs> = {
-    (args?: RequestArgs<TArgs> | null): void;
+    (executeArgs?: QueryExecuteArgs<TArgs>): void;
     reset: () => void;
+    currentRepositoryKey: Signal<string | false>;
 };
-export declare const createExecuteFn: <TArgs extends QueryArgs>(options: CreateQueryExecuteOptions<TArgs>) => QueryExecute<TArgs>;
+export declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => QueryExecute<TArgs>;

package/lib/experimental/query-features.d.ts

@@ -2,6 +2,8 @@ import { HttpErrorResponse, HttpEvent } from '@angular/common/http';
 import { Signal } from '@angular/core';
 import { QueryArgs, RequestArgs, ResponseType } from './query';
 import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
+import { QueryDependencies } from './query-dependencies';
+import { QueryExecute } from './query-execute';
 import { QueryState } from './query-state';
 import { QueryArgsReset, QueryFeatureFlags } from './query-utils';
 export declare const enum QueryFeatureType {
@@ -17,7 +19,8 @@ export type QueryFeatureContext<TArgs extends QueryArgs> = {
     queryConfig: QueryConfig;
     creatorConfig: CreateQueryCreatorOptions<TArgs>;
     creatorInternals: InternalCreateQueryCreatorOptions;
-    execute: (args: RequestArgs<TArgs>) => void;
+    execute: QueryExecute<TArgs>;
+    deps: QueryDependencies;
     flags: QueryFeatureFlags;
 };
 export type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;

package/lib/experimental/query-repository.d.ts

@@ -1,31 +1,52 @@
-import { HttpHeaders } from '@angular/common/http';
 import { DestroyRef } from '@angular/core';
-import { HttpRequest } from './http-request';
-import { BodyType, PathParamsType, QueryArgs, QueryParamsType } from './query';
+import { CreateHttpRequestClientOptions, HttpRequest } from './http-request';
+import { QueryArgs, RequestArgs } from './query';
 import { QueryClientConfig } from './query-client-config';
 import { QueryMethod, RouteType } from './query-creator';
+import { RunQueryExecuteOptions } from './query-execute-utils';
 export type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
-    method: QueryMethod;
+    /**
+     * The route of the request.
+     * @example '/users'
+     * @example (args) => `/users/${args.userId}`
+     */
     route: RouteType<TArgs>;
-    pathParams?: PathParamsType<TArgs>;
-    queryParams?: QueryParamsType<TArgs>;
-    body?: BodyType<TArgs>;
-    headers?: HttpHeaders;
-    reportProgress?: boolean;
-    withCredentials?: boolean;
-    transferCache?: boolean | {
-        includeHeaders?: string[];
-    };
-    responseType?: 'json';
+    /** The HTTP method of the request */
+    method: QueryMethod;
+    /** 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;
-    skipExecution?: boolean;
+    /** 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. */
     destroyRef: DestroyRef;
+    /** Configuration on how to run the query */
+    runQueryOptions?: RunQueryExecuteOptions;
+};
+export 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.
+ */
 export type QueryRepository = {
-    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => {
-        key: string | false;
-        request: HttpRequest<TArgs>;
-    };
-    unbind: (key: string | false, destroyRef: DestroyRef) => void;
+    /** 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, destroyRef: DestroyRef) => boolean;
 };
+/** The key of a query */
+export type QueryKey = string;
+/** A key that will not be cached */
+export type QueryKeyNoCache = false;
+/** A key that may or may not be cached */
+export type QueryKeyOrNone = QueryKey | QueryKeyNoCache;
 export declare const createQueryRepository: (config: QueryClientConfig) => QueryRepository;

package/lib/experimental/query-snapshot.d.ts

@@ -1,8 +1,10 @@
 import { QueryArgs, QuerySnapshot } from './query';
 import { QueryDependencies } from './query-dependencies';
+import { QueryExecute } from './query-execute';
 import { QueryState } from './query-state';
 export type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
     state: QueryState<TArgs>;
     deps: QueryDependencies;
+    execute: QueryExecute<TArgs>;
 };
 export declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;

package/lib/experimental/query-stack.d.ts

@@ -0,0 +1,46 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { AnyQuery } from './query';
+export type QueryStack<T extends AnyQuery, J = ReturnType<T['response']>[]> = {
+    /** Contains all queries in the stack. */
+    queries: Signal<T[]>;
+    /** Contains the last query in the stack. Useful for getting current pagination values. */
+    lastQuery: Signal<T | null>;
+    /** True if any query in the stack is loading. */
+    loading: Signal<boolean>;
+    /** Contains the first error that occurred in the stack. */
+    error: Signal<HttpErrorResponse | null>;
+    /** Contains the responses of all queries in the stack. Will be `null` for queries that are loading or errored. */
+    response: Signal<J>;
+    /** Executes all queries in the stack. */
+    execute: () => void;
+    /** Destroys all queries in the stack and empties it. This should only be used if `append` is true. */
+    clear: () => void;
+};
+export type AnyQueryStack = QueryStack<AnyQuery>;
+export type CreateQueryStackOptions<T extends AnyQuery, J = ReturnType<T['response']>[]> = {
+    /**
+     * 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: T[], newQueries: T[]) => {
+        /** The new queries merged with the old ones. */
+        queries: T[];
+        /** The last query in the new queries. */
+        lastQuery: T | null;
+    };
+    /**
+     * Transforms the responses of all queries in the stack. Useful for merging or filtering responses.
+     */
+    transform?: (responses: ReturnType<T['response']>[]) => J;
+};
+export declare const transformArrayResponse: <T extends (unknown | null)[]>(responses: T) => NonNullable<T[0]>[];
+export declare const transformPaginatedResponse: <T extends ({
+    items: unknown[];
+} | null)[]>(responses: T) => NonNullable<NonNullable<T[0]>["items"]>;
+export declare const createQueryStack: <T extends AnyQuery, J = ReturnType<T["response"]>[]>(computation: () => T | T[], options?: CreateQueryStackOptions<T, J>) => QueryStack<T, J>;

package/lib/experimental/query-utils.d.ts

@@ -1,9 +1,10 @@
 import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
 import { CreateEffectOptions } from '@angular/core';
-import { CreateQueryOptions, QueryArgs } from './query';
+import { CreateQueryOptions, Query, QueryArgs, QuerySnapshot } from './query';
 import { QueryMethod } from './query-creator';
 import { QueryExecute } from './query-execute';
 import { QueryFeatureContext } from './query-features';
+import { QueryState } from './query-state';
 /**
  * Returning this inside e.g. a withComputedArgs feature will reset the query args to null.
  * This will also pause polling and auto refresh until new args are set.
@@ -12,7 +13,7 @@ export declare const QUERY_ARGS_RESET: unique symbol;
 export type QueryArgsReset = typeof QUERY_ARGS_RESET;
 export declare const QUERY_EFFECT_ERROR_MESSAGE = "Effect triggered too often. This is probably due to a circular dependency inside the query.";
 /** A angular effect that will throw an error in dev mode if it is called too often. This indicates a circular dependency inside the effect. */
-export declare const queryEffect: (fn: () => void, errorMessage: string, options?: CreateEffectOptions) => void;
+export declare const queryEffect: (fn: () => void, errorMessage: string, options?: CreateEffectOptions) => import("@angular/core").EffectRef;
 export declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
 export declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
 export type ShouldRetryRequestOptions = {
@@ -39,3 +40,10 @@ export declare const maybeExecute: <TArgs extends QueryArgs>(options: {
     flags: QueryFeatureFlags;
     execute: QueryExecute<TArgs>;
 }) => void;
+export type CreateQueryObjectOptions<TArgs extends QueryArgs> = {
+    state: QueryState<TArgs>;
+    execute: QueryExecute<TArgs>;
+    createSnapshot: () => QuerySnapshot<TArgs>;
+    destroy: () => void;
+};
+export declare const createQueryObject: <TArgs extends QueryArgs>(options: CreateQueryObjectOptions<TArgs>) => Query<TArgs>;

package/lib/experimental/query.d.ts

@@ -11,11 +11,11 @@ export type QueryArgs = {
     body?: any;
     headers?: HttpHeaders;
 };
-export type ResponseType<T extends QueryArgs> = T['response'];
-export type PathParamsType<T extends QueryArgs> = T['pathParams'];
-export type QueryParamsType<T extends QueryArgs> = T['queryParams'];
-export type BodyType<T extends QueryArgs> = T['body'];
-export type RequestArgs<T extends QueryArgs> = Omit<T, 'response'>;
+export type ResponseType<T extends QueryArgs | null> = T extends QueryArgs ? T['response'] : never;
+export type PathParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['pathParams'] : never;
+export type QueryParamsType<T extends QueryArgs | null> = T extends QueryArgs ? T['queryParams'] : never;
+export type BodyType<T extends QueryArgs | null> = T extends QueryArgs ? T['body'] : never;
+export type RequestArgs<T extends QueryArgs | null> = T extends QueryArgs ? Omit<T, 'response'> : never;
 export type CreateQueryOptions<TArgs extends QueryArgs> = {
     creator: CreateQueryCreatorOptions<TArgs>;
     creatorInternals: InternalCreateQueryCreatorOptions;
@@ -29,13 +29,16 @@ export type QueryBase<TArgs extends QueryArgs> = {
     loading: Signal<HttpRequestLoadingState | null>;
     error: Signal<HttpErrorResponse | null>;
     lastTimeExecutedAt: Signal<number | null>;
+    id: Signal<string | false>;
 };
 export type QuerySnapshot<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     isAlive: Signal<boolean>;
 };
 export type AnyQuerySnapshot = QuerySnapshot<any>;
+export type AnyQuery = Query<any>;
 export type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     execute: QueryExecute<TArgs>;
     createSnapshot: () => QuerySnapshot<TArgs>;
+    destroy: () => void;
 };
 export declare const createQuery: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => Query<TArgs>;

package/lib/experimental/secure-query.d.ts

@@ -1,6 +1,6 @@
-import { CreateQueryOptions, Query, QueryArgs } from './query';
+import { CreateQueryOptions, QueryArgs } from './query';
 import { InternalSecureCreateQueryCreatorOptions } from './secure-query-creator';
 export type CreateSecureQueryOptions<TArgs extends QueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creatorInternals'> & {
     creatorInternals: InternalSecureCreateQueryCreatorOptions;
 };
-export declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => Query<TArgs>;
+export declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => import("./query").Query<TArgs>;

package/lib/query-form/query-form.types.d.ts

@@ -64,6 +64,14 @@ export interface QueryFieldOptions<T = unknown> {
      * @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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "5.19.0",
+  "version": "5.20.1",
   "peerDependencies": {
     "@angular/common": "^18.1.0",
     "@angular/core": "^18.1.0",