@ethlete/query 5.16.0 → 5.16.2

package/{src/index.ts → index.d.ts}

@@ -16,5 +16,3 @@ export * from './lib/query-store';
 export * from './lib/request';
 export * from './lib/symfony';
 export * from './lib/utils';
-
-// Burst cache

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

@@ -0,0 +1,133 @@
+import { AnyQueryCreator, QueryArgsOf, QueryResponseOf } from '../query-creator';
+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;
+}

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

@@ -0,0 +1,9 @@
+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>(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/basic-auth-provider.d.ts

@@ -0,0 +1,10 @@
+import { AuthProvider, AuthProviderBasicConfig } from './auth-provider.types';
+export declare class BasicAuthProvider implements AuthProvider {
+    _config: AuthProviderBasicConfig;
+    get header(): {
+        Authorization: string;
+    };
+    private get _basicAuthString();
+    constructor(_config: AuthProviderBasicConfig);
+    cleanUp(): void;
+}

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

@@ -0,0 +1,23 @@
+import { AnyQueryCreator, ConstructQuery } from '../query-creator';
+import { AuthProvider, AuthProviderBearerConfig, TokenResponse } from './auth-provider.types';
+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;
+    private _setCookie;
+    private _deleteCookie;
+    private _prepareForRefresh;
+}

package/lib/auth/custom-header-auth-provider.d.ts

@@ -0,0 +1,9 @@
+import { AuthProvider, AuthProviderCustomHeaderConfig } from './auth-provider.types';
+export declare class CustomHeaderAuthProvider implements AuthProvider {
+    _config: AuthProviderCustomHeaderConfig;
+    get header(): {
+        [x: string]: string;
+    };
+    constructor(_config: AuthProviderCustomHeaderConfig);
+    cleanUp(): void;
+}

package/{src/lib/class-validator/class-validator.types.ts → lib/class-validator/class-validator.types.d.ts}

@@ -1,7 +1,6 @@
 import { HttpStatusCode } from '../request';
-
 export interface ClassValidatorError {
-  statusCode: HttpStatusCode;
-  message: string[];
-  error: string;
+    statusCode: HttpStatusCode;
+    message: string[];
+    error: string;
 }

package/lib/class-validator/class-validator.utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValidatorError } from './class-validator.types';
+export declare const isClassValidatorError: (error: unknown) => error is ClassValidatorError;

package/lib/devtools/components/query-devtools/query-devtools.component.d.ts

@@ -0,0 +1,151 @@
+import { TrackByFunction } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { BasicAuthProvider, CustomHeaderAuthProvider } from '../../../auth';
+import { EntityStore } from '../../../entity';
+import { AnyQuery } from '../../../query';
+import { QueryClientDevtoolsOptions } from '../../utils';
+import * as i0 from "@angular/core";
+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("../../../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("../../../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("../../../query").QueryAutoRefreshConfig | undefined;
+        enableSmartPolling: boolean | undefined;
+        hasEntityStore: boolean;
+    } | null>;
+    protected readonly authProvider: import("@angular/core").Signal<import("../../../auth").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("../../../auth").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("../../../auth").AuthBearerRefreshStrategy | "AuthBearerRefreshStrategy.BeforeExpiration (default)";
+                readonly requestArgsAdapter: "custom" | "default";
+                readonly responseAdapter: "custom" | "default";
+            };
+            readonly name?: undefined;
+            readonly value?: undefined;
+            readonly username?: undefined;
+            readonly password?: undefined;
+        };
+    } | {
+        readonly type: "UnknownAuthProvider";
+        readonly header: () => Record<string, string>;
+        readonly provider: import("../../../auth").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 {};

package/lib/devtools/pipes/query-short-name.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { AnyQuery } from '../../query';
+import * as i0 from "@angular/core";
+export declare class QueryShortNamePipe implements PipeTransform {
+    transform(value: AnyQuery): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryShortNamePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<QueryShortNamePipe, "queryShortName", true>;
+}

package/lib/devtools/utils/query-client.utils.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+import { QueryClient } from '../../query-client';
+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;
+};

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

@@ -0,0 +1,15 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _infinityQuery;
+    private _destroy;
+    private _observer;
+    click$: import("rxjs").Observable<unknown>;
+    scrollContainerSelector: string | null;
+    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; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,49 @@
+import { InjectionToken } from '@angular/core';
+import { InfinityQueryConfig, InfinityQueryOf } from '../infinite-query';
+import { BaseArguments } from '../query';
+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;
+    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>>;
+export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> {
+    private readonly _queryConfigChanged$;
+    private readonly _viewContext;
+    private _infinityQueryInstance;
+    private readonly _destroy$;
+    private readonly _cdr;
+    private readonly _viewContainerRef;
+    private readonly _mainTemplateRef;
+    private readonly _errorHandler;
+    private readonly _delayable;
+    private readonly _data$;
+    get infinityQuery(): Q;
+    set infinityQuery(v: Q);
+    private _infinityQuery;
+    get context(): InfinityQueryContext<Q>;
+    get instance(): InfinityQueryOf<Q> | null;
+    get data$(): import("rxjs").Observable<Q["response"]["arrayType"]>;
+    data: import("@angular/core").Signal<Q["response"]["arrayType"]>;
+    static ngTemplateContextGuard<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
+    constructor();
+    private _setupInfinityQuery;
+    loadNextPage(): void;
+    reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
+    private _cleanup;
+    static ɵfac: 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 {};

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

@@ -0,0 +1,63 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { AnyQuery, AnyQueryCollection, QueryCollectionKeysOf, QueryOf } from '../query';
+import { QueryDataOf } from '../query-creator';
+import { RequestError, RequestProgress } from '../request';
+import * as i0 from "@angular/core";
+interface QueryContext<Q extends AnyQuery | AnyQueryCollection | null> {
+    /**
+     * The queries's response data.
+     */
+    $implicit: QueryDataOf<QueryOf<Q>> | null;
+    /**
+     * The queries's response data.
+     */
+    etQuery: QueryDataOf<QueryOf<Q>> | null;
+    /**
+     * The query used inside this directive. Useful if for instance the query gets unwrapped via async pipe inside the directive.
+     */
+    query: QueryOf<Q> | null;
+    /**
+     * Is true when the query is triggered by user interaction.
+     */
+    loading: boolean;
+    /**
+     * Is true when the query is triggered by either polling or auto refresh event.
+     */
+    refreshing: boolean;
+    /**
+     * The query's progress state.
+     */
+    progress: RequestProgress | null;
+    /**
+     * The query's error state.
+     */
+    error: RequestError<unknown> | null;
+    /**
+     * The query's scope (only available when the query is a collection)
+     */
+    scope: QueryCollectionKeysOf<Q> | null;
+}
+export declare class QueryDirective<Q extends AnyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {
+    private _mainTemplateRef;
+    private _viewContainerRef;
+    private _errorHandler;
+    private _cdr;
+    private _isMainViewCreated;
+    private _subscription;
+    private readonly _viewContext;
+    get query(): Q;
+    set query(v: Q);
+    private _query;
+    get cache(): boolean;
+    set cache(v: boolean);
+    private _cache;
+    static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryCollection | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<Q>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _subscribeToQuery;
+    private _updateView;
+    private _renderMainView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[etQuery]", never, { "query": { "alias": "etQuery"; "required": false; }; "cache": { "alias": "etQueryCache"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { EntityKey, EntityStoreConfig } from './entity.types';
+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;
+}

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

@@ -0,0 +1,25 @@
+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;
+}

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

@@ -0,0 +1,12 @@
+import { Paginated } from '@ethlete/types';
+import { EntityStore } from './entity-store';
+import { EntityKey, InsertFromConfig, RemoveFromConfig } from './entity.types';
+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;

package/lib/gql/gql.d.ts

@@ -0,0 +1,6 @@
+export declare const transformGql: (str: string) => (variables: Record<string, unknown> | null | undefined) => {
+    query: string;
+    variables?: string;
+    operationName?: string;
+};
+export declare const gql: (strings: TemplateStringsArray, ...values: string[]) => string;

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

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryDataOf } from '../query-creator';
+import { InfinityQueryConfig } from './infinity-query.types';
+export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, 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;
+}