@ethlete/query 2.9.2 → 3.0.1

package/index.d.ts

@@ -6,6 +6,7 @@ export * from './lib/infinite-query';
 export * from './lib/logger';
 export * from './lib/query';
 export * from './lib/query-client';
+export * from './lib/query-creator';
 export * from './lib/query-form';
 export * from './lib/query-store';
 export * from './lib/request';

package/lib/auth/auth-provider.types.d.ts

@@ -1,5 +1,4 @@
-import { QueryResponseType } from '../query';
-import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
+import { AnyQueryCreator, QueryArgsOf, QueryResponseOf } from '../query-creator';
 export interface AuthProvider {
     /**
      * The up to date auth header.
@@ -89,12 +88,12 @@ export interface BearerRefreshConfig<T extends AnyQueryCreator> {
     requestArgsAdapter?: (tokens: {
         token: string | null;
         refreshToken: string;
-    }) => QueryCreatorArgs<T>;
+    }) => QueryArgsOf<T>;
     /**
      * Adapter function used to extract the token and refreshToken from the response.
      * @default { token: "token", refreshToken: "refreshToken" }
      */
-    responseAdapter?: (response: NonNullable<QueryResponseType<QueryCreatorReturnType<T>>>) => TokenResponse;
+    responseAdapter?: (response: NonNullable<QueryResponseOf<T>>) => TokenResponse;
 }
 export declare const enum AuthBearerRefreshStrategy {
     /**

package/lib/auth/auth-provider.utils.d.ts

@@ -1,9 +1,9 @@
-import { AnyQueryCreator } from '../query-client';
+import { AnyQueryCreator } from '../query-creator';
 import { AuthProvider } from './auth-provider.types';
 import { BasicAuthProvider } from './basic-auth-provider';
 import { BearerAuthProvider } from './bearer-auth-provider';
 import { CustomHeaderAuthProvider } from './custom-header-auth-provider';
 export declare const isBasicAuthProvider: (authProvider: AuthProvider) => authProvider is BasicAuthProvider;
-export declare const isBearerAuthProvider: <T extends AnyQueryCreator = AnyQueryCreator>(authProvider: AuthProvider) => authProvider is BearerAuthProvider<T>;
+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;

package/lib/auth/bearer-auth-provider.d.ts

@@ -1,4 +1,4 @@
-import { AnyQueryCreator } from '../query-client';
+import { AnyQueryCreator } from '../query-creator';
 import { AuthProvider, AuthProviderBearerConfig, TokenResponse } from './auth-provider.types';
 export declare class BearerAuthProvider<T extends AnyQueryCreator> implements AuthProvider {
     private _config;

package/lib/directives/infinity-query-trigger.directive.d.ts

@@ -11,5 +11,5 @@ export declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy
     ngOnDestroy(): void;
     private _setupIntersectionObserver;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[infinityQueryTrigger], infinity-query-trigger", never, { "scrollContainerSelector": "scrollContainerSelector"; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[etInfinityQueryTrigger], et-infinity-query-trigger", never, { "scrollContainerSelector": "scrollContainerSelector"; }, {}, never, never, true, never>;
 }

package/lib/directives/infinity-query.directive.d.ts

@@ -1,13 +1,13 @@
-import { InjectionToken, OnDestroy, OnInit } from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
 import { InfinityQueryConfig, InfinityQueryOf } from '../infinite-query';
 import { BaseArguments } from '../query';
-import { AnyQueryCreator } from '../query-client';
+import { AnyQueryCreator, ConstructQuery } from '../query-creator';
 import { RequestError } from '../request';
 import * as i0 from "@angular/core";
 import * as i1 from "@ethlete/core";
 interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> {
     $implicit: Q['response']['arrayType'] | null;
-    infinityQuery: Q['response']['arrayType'] | null;
+    etInfinityQuery: Q['response']['arrayType'] | null;
     loading: boolean;
     error: RequestError<unknown> | null;
     isFirstLoad: boolean;
@@ -16,9 +16,10 @@ interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, Ba
     currentCalculatedPage: number | null;
     totalPages: number | null;
     itemsPerPage: number | null;
+    currentQuery: ConstructQuery<Q['queryCreator']> | null;
 }
 export declare const INFINITY_QUERY_TOKEN: InjectionToken<InfinityQueryDirective<any>>;
-export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> implements OnInit, OnDestroy {
+export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> implements OnInit {
     private readonly _queryConfigChanged$;
     private readonly _viewContext;
     private _infinityQueryInstance;
@@ -40,18 +41,12 @@ export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQue
     get data(): Q["response"]["arrayType"];
     static ngTemplateContextGuard<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
     ngOnInit(): void;
-    ngOnDestroy(): void;
     private _setupInfinityQuery;
-    /**
-     * @deprecated Use `loadNextPage` instead
-     * @breaking 3.0.0
-     */
-    _loadNextPage(): void;
     loadNextPage(): void;
     reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
     private _renderMainView;
     private _cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, [{ directive: typeof i1.DelayableDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[etInfinityQuery]", ["etInfinityQuery"], { "infinityQuery": "etInfinityQuery"; }, {}, never, never, true, [{ directive: typeof i1.DelayableDirective; inputs: {}; outputs: {}; }]>;
 }
 export {};

package/lib/directives/query.directive.d.ts

@@ -1,16 +1,16 @@
 import { ChangeDetectorRef, ErrorHandler, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
-import { AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, QueryOf, QueryRawResponseType, QueryResponseType } from '../query';
+import { AnyQuery, AnyQueryCollection, QueryOf } from '../query';
+import { QueryDataOf } from '../query-creator';
 import { RequestError, RequestProgress } from '../request';
 import * as i0 from "@angular/core";
 interface QueryContext<Q extends AnyQuery | null> {
-    $implicit: QueryResponseType<Q>;
-    query: QueryResponseType<Q>;
-    raw: QueryRawResponseType<Q>;
+    $implicit: QueryDataOf<Q>;
+    etQuery: QueryDataOf<Q>;
     loading: boolean;
     progress: RequestProgress | null;
     error: RequestError<unknown> | null;
 }
-export declare class QueryDirective<Q extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null> implements OnInit, OnDestroy {
+export declare class QueryDirective<Q extends AnyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {
     private _mainTemplateRef;
     private _viewContainerRef;
     private _errorHandler;
@@ -25,13 +25,13 @@ export declare class QueryDirective<Q extends AnyQuery | AnyQueryOfCreatorCollec
     set cache(v: boolean);
     private _cache;
     constructor(_mainTemplateRef: TemplateRef<QueryContext<QueryOf<Q>>>, _viewContainerRef: ViewContainerRef, _errorHandler: ErrorHandler, _cdr: ChangeDetectorRef);
-    static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<QueryOf<Q>>;
+    static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryCollection | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<QueryOf<Q>>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private _subscribeToQuery;
     private _updateView;
     private _renderMainView;
     static ɵfac: i0.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[query]", never, { "query": "query"; "cache": "queryCache"; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, { "query": "etQuery"; "cache": "etQueryCache"; }, {}, never, never, true, never>;
 }
 export {};

package/lib/entity/entity-store.d.ts

@@ -1,33 +1,19 @@
-import { EntityKey, EntityStoreActionResult, EntityStoreConfig } from './entity.types';
+import { Observable } from 'rxjs';
+import { EntityKey, EntityStoreConfig } from './entity.types';
 export declare class EntityStore<T> {
     private readonly _config;
     private readonly _dictionary;
-    private readonly _keys;
-    private readonly _events$;
-    get events$(): import("rxjs").Observable<EntityStoreActionResult>;
-    get keys(): EntityKey[];
-    get values(): T[];
-    get size(): number;
-    get isEmpty(): boolean;
-    get config(): EntityStoreConfig;
-    get idKey(): string;
-    readonly entities$: import("rxjs").Observable<{
-        keys: EntityKey[];
-        values: T[];
-    }>;
+    private readonly _change$;
     constructor(_config: EntityStoreConfig);
-    getOne(key: EntityKey): NonNullable<T> | null;
-    getMany(keys: EntityKey[]): (NonNullable<T> | null)[];
-    addOne(value: T): EntityStoreActionResult | null;
-    addMany(values: T[]): (EntityStoreActionResult | null)[];
-    updateOne(value: T): EntityStoreActionResult | null;
-    updateMany(values: T[]): (EntityStoreActionResult | null)[];
-    setOne(value: T): EntityStoreActionResult;
-    setMany(values: T[]): EntityStoreActionResult[];
-    removeOne(key: EntityKey): EntityStoreActionResult | null;
-    removeMany(keys: EntityKey[]): (EntityStoreActionResult | null)[];
-    has(key: EntityKey): boolean;
-    clear(): void;
-    getKey(value: T): string | number;
+    select(key: EntityKey): Observable<T | null>;
+    select(keys: EntityKey[]): Observable<T[]>;
+    set(key: EntityKey, value: T): void;
+    set(keys: EntityKey[], values: T[]): void;
+    remove(key: EntityKey): void;
+    remove(keys: EntityKey[]): void;
     logState(): void;
+    private _select;
+    private _selectMany;
+    private _set;
+    private _remove;
 }

package/lib/entity/entity.types.d.ts

@@ -1,10 +1,5 @@
 export type EntityKey = string | number;
-export type EntityStoreActionResult = {
-    type: 'add' | 'update' | 'set' | 'remove';
-    key: EntityKey;
-};
 export interface EntityStoreConfig {
     name: string;
-    idKey?: string;
     logActions?: boolean;
 }

package/lib/entity/entity.utils.d.ts

@@ -0,0 +1,2 @@
+import { Paginated } from '@ethlete/types';
+export declare function mapToPaginated<T>(response: Paginated<T>): import("rxjs").OperatorFunction<unknown, Paginated<T>>;

package/lib/entity/index.d.ts

@@ -1,2 +1,3 @@
 export * from './entity-store';
 export * from './entity.types';
+export * from './entity.utils';

package/lib/infinite-query/infinity-query.d.ts

@@ -1,36 +1,27 @@
-import { Observable } from 'rxjs';
-import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorResponse, QueryCreatorReturnType } from '../query-client';
+import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryResponseOf } from '../query-creator';
 import { InfinityQueryConfig } from './infinity-query.types';
-export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends QueryCreatorReturnType<QueryCreator>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryCreatorResponse<QueryCreator>, InfinityResponse extends unknown[]> {
+export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends ConstructQuery<QueryCreator>, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryResponseOf<QueryCreator>, InfinityResponse extends unknown[]> {
     private _config;
+    private readonly _queries$;
     private readonly _currentPage$;
     private readonly _currentCalculatedPage$;
     private readonly _totalPages$;
     private readonly _itemsPerPage$;
-    private readonly _currentQuery$;
     private readonly _data$;
-    private _subscriptions;
-    private _responsiveDataSubscription;
-    get currentPage$(): Observable<number | null>;
+    private readonly _lastQuery$;
+    get currentPage$(): import("rxjs").Observable<number | null>;
     get currentPage(): number | null;
-    get currentCalculatedPage$(): Observable<number | null>;
+    get currentCalculatedPage$(): import("rxjs").Observable<number | null>;
     get currentCalculatedPage(): number | null;
-    get totalPages$(): Observable<number | null>;
+    get totalPages$(): import("rxjs").Observable<number | null>;
     get totalPages(): number | null;
-    get itemsPerPage$(): Observable<number>;
+    get itemsPerPage$(): import("rxjs").Observable<number>;
     get itemsPerPage(): number;
-    get currentQuery$(): Observable<Query | null>;
-    get currentQuery(): Query | null;
-    get data$(): Observable<InfinityResponse>;
-    get data(): InfinityResponse;
+    get data$(): import("rxjs").Observable<InfinityResponse>;
+    get currentQuery$(): import("rxjs").Observable<Query>;
     constructor(_config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>);
     nextPage(): void;
     reset(newConfig?: Omit<InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>, 'queryCreator' | 'response'>): void;
-    /**
-     * @internal
-     */
-    _clearSubscriptions(): void;
-    private _handleNewQuery;
     private _prepareArgs;
     private _getPageParamLocation;
 }

package/lib/infinite-query/infinity-query.types.d.ts

@@ -1,5 +1,5 @@
-import { BaseArguments, QueryStateData } from '../query';
-import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorResponse, QueryCreatorReturnType } from '../query-client';
+import { BaseArguments } from '../query';
+import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryResponseOf } from '../query-creator';
 import { InfinityQuery } from './infinity-query';
 export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
 export type AppendItemsLocation = 'start' | 'end';
@@ -93,6 +93,6 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
 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, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
-export type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig> = InfinityQuery<Cfg['queryCreator'], QueryCreatorReturnType<Cfg['queryCreator']>, QueryCreatorArgs<Cfg['queryCreator']>, QueryCreatorResponse<Cfg['queryCreator']>, Cfg['response']['arrayType']>;
+export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryArgsOf<QueryCreator>>, QueryResponseOf<QueryCreator>, InfinityResponse>;
+export type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig> = InfinityQuery<Cfg['queryCreator'], ConstructQuery<Cfg['queryCreator']>, QueryArgsOf<Cfg['queryCreator']>, QueryResponseOf<Cfg['queryCreator']>, Cfg['response']['arrayType']>;
 export {};

package/lib/infinite-query/infinity-query.utils.d.ts

@@ -1,5 +1,4 @@
-import { QueryStateData } from '../query';
-import { AnyQueryCreator, QueryCreatorArgs } from '../query-client';
+import { AnyQueryCreator, QueryArgsOf, QueryResponseOf } from '../query-creator';
 import { InfinityQueryConfig, PageParamCalculatorOptions } from './infinity-query.types';
-export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator, Query extends ReturnType<QueryCreator["prepare"]>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryStateData<Query["state"]>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
+export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator, Args extends QueryArgsOf<QueryCreator>, QueryResponse extends QueryResponseOf<QueryCreator>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
 export declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;

package/lib/query/query.d.ts

@@ -1,14 +1,15 @@
-import { QueryClient, ResponseTransformerType } from '../query-client';
-import { Method as MethodType } from '../request';
-import { BaseArguments, GqlQueryConfig, PollConfig, QueryAutoRefreshConfig, QueryState, RestQueryConfig, RouteType, RunQueryOptions, WithUseResultIn } from './query.types';
-export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response>, Entity> {
+import { Observable } from 'rxjs';
+import { EntityStore } from '../entity';
+import { QueryClient } from '../query-client';
+import { BaseArguments, ExecuteQueryOptions, GqlQueryConfig, PollConfig, QueryAutoRefreshConfig, QueryState, RestQueryConfig, RouteType } from './query.types';
+export declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
     private _client;
     private _queryConfig;
     private _routeWithParams;
     private _args;
     private _currentId;
     private _pollingSubscription;
-    private _entitySubscription;
+    private _requestSubscription;
     private _onAbort$;
     private _currentPollConfig;
     /**
@@ -17,8 +18,14 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
     _isPollingPaused: boolean;
     private readonly _state$;
     private get _nextId();
-    get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
-    get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
+    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;
@@ -27,19 +34,19 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
      * @internal
      */
     get _enableSmartPolling(): boolean;
-    get store(): import("@ethlete/query").EntityStore<Entity> | null;
-    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, _routeWithParams: Route, _args: Arguments);
-    clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer, Entity>;
-    execute<ComputedResponse extends ReturnType<ResponseTransformer>, EntityResponse extends ResponseTransformer extends (response: Response) => infer R ? R : Response>(options?: RunQueryOptions): this;
+    get store(): Store | null;
+    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, _routeWithParams: Route, _args: Arguments);
+    execute(options?: ExecuteQueryOptions): this;
     abort(): this;
     poll(config: PollConfig): this;
     stopPolling(): this;
     pausePolling(): this;
     resumePolling(): this;
-    private _updateUseResultInDependencies;
     /**
      * @internal
      */
     _destroy(): void;
     private _getBearerAuthProvider;
+    private _updateEntityState;
+    private _transformState;
 }

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

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
-import { EntityStore, EntityStoreActionResult } from '../entity';
-import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
+import { EntityStore } from '../entity';
+import { AnyQueryCreator, ConstructQuery, QueryResponseOf } from '../query-creator';
 import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
 import { Query } from './query';
 export interface QueryAutoRefreshConfig {
@@ -17,7 +17,71 @@ export interface QueryAutoRefreshConfig {
      */
     windowFocus?: boolean;
 }
-export type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = {
+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.
      */
@@ -27,11 +91,6 @@ export type QueryConfigBase<Response, Arguments extends BaseArguments | undefine
      * The query **will throw** if the query client's auth provider is unset.
      */
     secure?: boolean;
-    /**
-     * The response transformer to use for the query.
-     * A function that transforms the response to the desired type.
-     */
-    responseTransformer?: ResponseTransformer;
     /**
      * Determines if the query should emit progress events.
      */
@@ -79,33 +138,19 @@ export type QueryConfigBase<Response, Arguments extends BaseArguments | undefine
          */
         args?: Arguments;
     };
-    entity?: {
-        store: EntityStore<Entity>;
-        successAction: (data: {
-            rawResponse: Response;
-            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
-            args: Arguments;
-            store: EntityStore<Entity>;
-        }) => EntityStoreActionResult | null | Array<EntityStoreActionResult | null>;
-        valueUpdater?: (data: {
-            rawResponse: Response;
-            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
-            args: Arguments;
-            entity: Entity;
-        }) => {
-            rawResponse: Response;
-            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
-        } | null;
-    };
+    /**
+     * 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, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = QueryConfigBase<Response, Arguments, ResponseTransformer, Entity> & {
+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, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> extends QueryConfigBase<Response, Arguments, ResponseTransformer, Entity> {
+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.
      */
@@ -122,10 +167,10 @@ export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined,
      */
     route?: Route;
 }
-export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any>;
-export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any>;
-export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, 'method'>;
-export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, 'method'>;
+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;
 export interface WithHeaders {
     headers?: Record<string, string>;
@@ -142,12 +187,9 @@ export interface WithQueryParams {
 export interface WithPathParams {
     pathParams?: PathParams;
 }
-export type WithUseResultIn<Response, ResponseTransformer extends ResponseTransformerType<Response>> = {
-    useResultIn?: Query<Response, any, any, any, ResponseTransformer, any>[];
-};
 export type QueryTrigger = 'program' | 'poll' | 'auto';
 export type EmptyObject = {};
-export interface RunQueryOptions {
+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
@@ -197,10 +239,9 @@ export interface Prepared {
     type: QueryStateType.Prepared;
     meta: QueryStateMeta;
 }
-export interface Success<Response = unknown, RawResponse = unknown> {
+export interface Success<Response = unknown> {
     type: QueryStateType.Success;
     response: Response;
-    rawResponse: RawResponse;
     meta: QueryStateSuccessMeta;
 }
 export interface Failure {
@@ -228,26 +269,20 @@ export interface QueryStateMeta {
 export interface QueryStateSuccessMeta extends QueryStateMeta {
     expiresAt?: number;
 }
-export type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
-export type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
-export type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
+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 QueryType<T extends {
-    prepare: (args: any) => AnyQuery;
-}> = T['prepare'] extends () => infer R ? R : T['prepare'] extends (args: any) => infer R ? R : never;
-export type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
-export type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;
 export type AnyQueryCreatorCollection = {
     [name: string]: AnyQueryCreator;
 };
-export type AnyQueryOfCreatorCollection<T extends {
+export type QueryCollectionOf<T extends {
     [name: string]: AnyQueryCreator;
 }> = {
     [K in keyof T]: {
         type: K;
-        query: QueryCreatorReturnType<T[K]>;
+        query: ConstructQuery<T[K]>;
     };
 }[keyof T];
-export type QueryOf<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> ? T['query'] : never;
-export type AnyQueryResponseOfCreatorCollection<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection>> = QueryResponseType<T['query']>;
-export type AnyQueryRawResponseOfCreatorCollection<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection>> = QueryRawResponseType<T['query']>;
+export type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;
+export type QueryOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyQueryCollection ? T['query'] : never;
+export type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;