@ngrx/data 20.1.0 → 21.0.0-rc.0

package/types/ngrx-data.d.ts

@@ -0,0 +1,3465 @@
+import * as _ngrx_store from '@ngrx/store';
+import { Action, Store, MemoizedSelector, Selector, MetaReducer, ActionReducer } from '@ngrx/store';
+import { Observable, OperatorFunction, SchedulerLike } from 'rxjs';
+import { Update, IdSelector, EntityState, Dictionary, Comparer, EntityAdapter } from '@ngrx/entity';
+import * as i0 from '@angular/core';
+import { InjectionToken, FactoryProvider, OnDestroy, ModuleWithProviders, Provider, EnvironmentProviders } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Actions } from '@ngrx/effects';
+import * as _ngrx_data from '@ngrx/data';
+
+/** General purpose entity action operations, good for any entity type */
+declare enum EntityOp {
+    CANCEL_PERSIST = "@ngrx/data/cancel-persist",
+    CANCELED_PERSIST = "@ngrx/data/canceled-persist",
+    QUERY_ALL = "@ngrx/data/query-all",
+    QUERY_ALL_SUCCESS = "@ngrx/data/query-all/success",
+    QUERY_ALL_ERROR = "@ngrx/data/query-all/error",
+    QUERY_LOAD = "@ngrx/data/query-load",
+    QUERY_LOAD_SUCCESS = "@ngrx/data/query-load/success",
+    QUERY_LOAD_ERROR = "@ngrx/data/query-load/error",
+    QUERY_MANY = "@ngrx/data/query-many",
+    QUERY_MANY_SUCCESS = "@ngrx/data/query-many/success",
+    QUERY_MANY_ERROR = "@ngrx/data/query-many/error",
+    QUERY_BY_KEY = "@ngrx/data/query-by-key",
+    QUERY_BY_KEY_SUCCESS = "@ngrx/data/query-by-key/success",
+    QUERY_BY_KEY_ERROR = "@ngrx/data/query-by-key/error",
+    SAVE_ADD_MANY = "@ngrx/data/save/add-many",
+    SAVE_ADD_MANY_ERROR = "@ngrx/data/save/add-many/error",
+    SAVE_ADD_MANY_SUCCESS = "@ngrx/data/save/add-many/success",
+    SAVE_ADD_ONE = "@ngrx/data/save/add-one",
+    SAVE_ADD_ONE_ERROR = "@ngrx/data/save/add-one/error",
+    SAVE_ADD_ONE_SUCCESS = "@ngrx/data/save/add-one/success",
+    SAVE_DELETE_MANY = "@ngrx/data/save/delete-many",
+    SAVE_DELETE_MANY_SUCCESS = "@ngrx/data/save/delete-many/success",
+    SAVE_DELETE_MANY_ERROR = "@ngrx/data/save/delete-many/error",
+    SAVE_DELETE_ONE = "@ngrx/data/save/delete-one",
+    SAVE_DELETE_ONE_SUCCESS = "@ngrx/data/save/delete-one/success",
+    SAVE_DELETE_ONE_ERROR = "@ngrx/data/save/delete-one/error",
+    SAVE_UPDATE_MANY = "@ngrx/data/save/update-many",
+    SAVE_UPDATE_MANY_SUCCESS = "@ngrx/data/save/update-many/success",
+    SAVE_UPDATE_MANY_ERROR = "@ngrx/data/save/update-many/error",
+    SAVE_UPDATE_ONE = "@ngrx/data/save/update-one",
+    SAVE_UPDATE_ONE_SUCCESS = "@ngrx/data/save/update-one/success",
+    SAVE_UPDATE_ONE_ERROR = "@ngrx/data/save/update-one/error",
+    SAVE_UPSERT_MANY = "@ngrx/data/save/upsert-many",
+    SAVE_UPSERT_MANY_SUCCESS = "@ngrx/data/save/upsert-many/success",
+    SAVE_UPSERT_MANY_ERROR = "@ngrx/data/save/upsert-many/error",
+    SAVE_UPSERT_ONE = "@ngrx/data/save/upsert-one",
+    SAVE_UPSERT_ONE_SUCCESS = "@ngrx/data/save/upsert-one/success",
+    SAVE_UPSERT_ONE_ERROR = "@ngrx/data/save/upsert-one/error",
+    ADD_ALL = "@ngrx/data/add-all",
+    ADD_MANY = "@ngrx/data/add-many",
+    ADD_ONE = "@ngrx/data/add-one",
+    REMOVE_ALL = "@ngrx/data/remove-all",
+    REMOVE_MANY = "@ngrx/data/remove-many",
+    REMOVE_ONE = "@ngrx/data/remove-one",
+    UPDATE_MANY = "@ngrx/data/update-many",
+    UPDATE_ONE = "@ngrx/data/update-one",
+    UPSERT_MANY = "@ngrx/data/upsert-many",
+    UPSERT_ONE = "@ngrx/data/upsert-one",
+    COMMIT_ALL = "@ngrx/data/commit-all",
+    COMMIT_MANY = "@ngrx/data/commit-many",
+    COMMIT_ONE = "@ngrx/data/commit-one",
+    UNDO_ALL = "@ngrx/data/undo-all",
+    UNDO_MANY = "@ngrx/data/undo-many",
+    UNDO_ONE = "@ngrx/data/undo-one",
+    SET_CHANGE_STATE = "@ngrx/data/set-change-state",
+    SET_COLLECTION = "@ngrx/data/set-collection",
+    SET_FILTER = "@ngrx/data/set-filter",
+    SET_LOADED = "@ngrx/data/set-loaded",
+    SET_LOADING = "@ngrx/data/set-loading"
+}
+/** "Success" suffix appended to EntityOps that are successful.*/
+declare const OP_SUCCESS = "/success";
+/** "Error" suffix appended to EntityOps that have failed.*/
+declare const OP_ERROR = "/error";
+/** Make the error EntityOp corresponding to the given EntityOp */
+declare function makeErrorOp(op: EntityOp): EntityOp;
+/** Make the success EntityOp corresponding to the given EntityOp */
+declare function makeSuccessOp(op: EntityOp): EntityOp;
+
+/** How to merge an entity, after query or save, when the corresponding entity in the collection has unsaved changes. */
+declare enum MergeStrategy {
+    /**
+     * Update the collection entities and ignore all change tracking for this operation.
+     * Each entity's `changeState` is untouched.
+     */
+    IgnoreChanges = 0,
+    /**
+     * Updates current values for unchanged entities.
+     * For each changed entity it preserves the current value and overwrites the `originalValue` with the merge entity.
+     * This is the query-success default.
+     */
+    PreserveChanges = 1,
+    /**
+     * Replace the current collection entities.
+     * For each merged entity it discards the `changeState` and sets the `changeType` to "unchanged".
+     * This is the save-success default.
+     */
+    OverwriteChanges = 2
+}
+
+/** A service that performs REST-like HTTP data operations for an entity collection */
+interface EntityCollectionDataService<T> {
+    readonly name: string;
+    add(entity: T, httpOptions?: HttpOptions): Observable<T>;
+    delete(id: number | string, httpOptions?: HttpOptions): Observable<number | string>;
+    getAll(httpOptions?: HttpOptions): Observable<T[]>;
+    getById(id: any, httpOptions?: HttpOptions): Observable<T>;
+    getWithQuery(params: QueryParams | string, httpOptions?: HttpOptions): Observable<T[]>;
+    update(update: Update<T>, httpOptions?: HttpOptions): Observable<T>;
+    upsert(entity: T, httpOptions?: HttpOptions): Observable<T>;
+}
+type HttpMethods = 'DELETE' | 'GET' | 'POST' | 'PUT';
+interface RequestData {
+    method: HttpMethods;
+    url: string;
+    data?: any;
+    options?: any;
+}
+/**
+ * A key/value map of parameters to be turned into an HTTP query string
+ * Same as HttpClient's HttpParamsOptions which at the time of writing was
+ * NOT exported at package level
+ * https://github.com/angular/angular/issues/22013
+ *
+ * @deprecated Use HttpOptions instead. getWithQuery still accepts QueryParams as its
+ * first argument, but HttpOptions.httpParams uses Angular's own HttpParamsOptions which
+ * HttpClient accepts as an argument.
+ */
+interface QueryParams {
+    [name: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+}
+/**
+ * Options that adhere to the constructor arguments for HttpParams and
+ * HttpHeaders.
+ */
+interface HttpOptions {
+    httpParams?: HttpParams;
+    httpHeaders?: HttpHeaders;
+}
+/**
+ * Type that adheres to angular's Http Headers
+ */
+type HttpHeaders = string | {
+    [p: string]: string | string[];
+};
+/**
+ * Options that partially adheres to angular's HttpParamsOptions. The non-serializable encoder property is omitted.
+ */
+declare interface HttpParams {
+    /**
+     * String representation of the HTTP parameters in URL-query-string format.
+     * Mutually exclusive with `fromObject`.
+     */
+    fromString?: string;
+    /** Object map of the HTTP parameters. Mutually exclusive with `fromString`. */
+    fromObject?: {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+}
+
+/** Action concerning an entity collection. */
+interface EntityAction<P = any> extends Action {
+    readonly type: string;
+    readonly payload: EntityActionPayload<P>;
+}
+/** Options of an EntityAction */
+interface EntityActionOptions {
+    /** Correlate related EntityActions, particularly related saves. Must be serializable. */
+    readonly correlationId?: any;
+    /** True if should perform action optimistically (before server responds) */
+    readonly isOptimistic?: boolean;
+    readonly mergeStrategy?: MergeStrategy;
+    /** The tag to use in the action's type. The entityName if no tag specified. */
+    readonly tag?: string;
+    /** Options that will be passed to the dataService http request. Allows setting of Query Parameters and Headers */
+    readonly httpOptions?: HttpOptions;
+    /**
+     * The action was determined (usually by a reducer) to be in error.
+     * Downstream effects should not process but rather treat it as an error.
+     */
+    error?: Error;
+    /**
+     * Downstream effects should skip processing this action but should return
+     * an innocuous Observable<Action> of success.
+     */
+    skip?: boolean;
+}
+/** Payload of an EntityAction */
+interface EntityActionPayload<P = any> extends EntityActionOptions {
+    readonly entityName: string;
+    readonly entityOp: EntityOp;
+    readonly data?: P;
+}
+
+declare class EntityActionFactory {
+    /**
+     * Create an EntityAction to perform an operation (op) for a particular entity type
+     * (entityName) with optional data and other optional flags
+     * @param entityName Name of the entity type
+     * @param entityOp Operation to perform (EntityOp)
+     * @param [data] data for the operation
+     * @param [options] additional options
+     */
+    create<P = any>(entityName: string, entityOp: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Create an EntityAction to perform an operation (op) for a particular entity type
+     * (entityName) with optional data and other optional flags
+     * @param payload Defines the EntityAction and its options
+     */
+    create<P = any>(payload: EntityActionPayload<P>): EntityAction<P>;
+    /**
+     * Create an EntityAction to perform an operation (op) for a particular entity type
+     * (entityName) with optional data and other optional flags
+     * @param payload Defines the EntityAction and its options
+     */
+    protected createCore<P = any>(payload: EntityActionPayload<P>): {
+        type: string;
+        payload: EntityActionPayload<P>;
+    };
+    /**
+     * Create an EntityAction from another EntityAction, replacing properties with those from newPayload;
+     * @param from Source action that is the base for the new action
+     * @param newProperties New EntityAction properties that replace the source action properties
+     */
+    createFromAction<P = any>(from: EntityAction, newProperties: Partial<EntityActionPayload<P>>): EntityAction<P>;
+    formatActionType(op: string, tag: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityActionFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityActionFactory>;
+}
+
+/**
+ * Data returned in an EntityAction from the EntityEffects for SAVE_UPDATE_ONE_SUCCESS.
+ * Effectively extends Update<T> with a 'changed' flag.
+ * The is true if the server sent back changes to the entity data after update.
+ * Such changes must be in the entity data in changes property.
+ * Default is false (server did not return entity data; assume it changed nothing).
+ * See EntityEffects.
+ */
+interface UpdateResponseData<T> {
+    /** Original key (id) of the entity */
+    id: number | string;
+    /** Entity update data. Should include the key (original or changed) */
+    changes: Partial<T>;
+    /**
+     * Whether the server made additional changes after processing the update.
+     * Such additional changes should be in the 'changes' object.
+     * Default is false
+     */
+    changed?: boolean;
+}
+
+/**
+ * Guard methods that ensure EntityAction payload is as expected.
+ * Each method returns that payload if it passes the guard or
+ * throws an error.
+ */
+declare class EntityActionGuard<T> {
+    private entityName;
+    private selectId;
+    constructor(entityName: string, selectId: IdSelector<T>);
+    /** Throw if the action payload is not an entity with a valid key */
+    mustBeEntity(action: EntityAction<T>): T;
+    /** Throw if the action payload is not an array of entities with valid keys */
+    mustBeEntities(action: EntityAction<T[]>): T[];
+    /** Throw if the action payload is not a single, valid key */
+    mustBeKey(action: EntityAction<string | number>): string | number | never;
+    /** Throw if the action payload is not an array of valid keys */
+    mustBeKeys(action: EntityAction<(string | number)[]>): (string | number)[];
+    /** Throw if the action payload is not an update with a valid key (id) */
+    mustBeUpdate(action: EntityAction<Update<T>>): Update<T>;
+    /** Throw if the action payload is not an array of updates with valid keys (ids) */
+    mustBeUpdates(action: EntityAction<Update<T>[]>): Update<T>[];
+    /** Throw if the action payload is not an update response with a valid key (id) */
+    mustBeUpdateResponse(action: EntityAction<UpdateResponseData<T>>): UpdateResponseData<T>;
+    /** Throw if the action payload is not an array of update responses with valid keys (ids) */
+    mustBeUpdateResponses(action: EntityAction<UpdateResponseData<T>[]>): UpdateResponseData<T>[];
+    private extractData;
+    /** Return true if this key (id) is invalid */
+    private isNotKeyType;
+    private throwError;
+}
+
+/**
+ * Select actions concerning one of the allowed Entity operations
+ * @param allowedEntityOps Entity operations (e.g, EntityOp.QUERY_ALL) whose actions should be selected
+ * Example:
+ * ```
+ *  this.actions.pipe(ofEntityOp(EntityOp.QUERY_ALL, EntityOp.QUERY_MANY), ...)
+ *  this.actions.pipe(ofEntityOp(...queryOps), ...)
+ *  this.actions.pipe(ofEntityOp(queryOps), ...)
+ *  this.actions.pipe(ofEntityOp(), ...) // any action with a defined `entityOp` property
+ * ```
+ */
+declare function ofEntityOp<T extends EntityAction>(allowedOps: string[] | EntityOp[]): OperatorFunction<EntityAction, T>;
+declare function ofEntityOp<T extends EntityAction>(...allowedOps: (string | EntityOp)[]): OperatorFunction<EntityAction, T>;
+/**
+ * Select actions concerning one of the allowed Entity types
+ * @param allowedEntityNames Entity-type names (e.g, 'Hero') whose actions should be selected
+ * Example:
+ * ```
+ *  this.actions.pipe(ofEntityType(), ...) // ayn EntityAction with a defined entity type property
+ *  this.actions.pipe(ofEntityType('Hero'), ...) // EntityActions for the Hero entity
+ *  this.actions.pipe(ofEntityType('Hero', 'Villain', 'Sidekick'), ...)
+ *  this.actions.pipe(ofEntityType(...theChosen), ...)
+ *  this.actions.pipe(ofEntityType(theChosen), ...)
+ * ```
+ */
+declare function ofEntityType<T extends EntityAction>(allowedEntityNames?: string[]): OperatorFunction<EntityAction, T>;
+declare function ofEntityType<T extends EntityAction>(...allowedEntityNames: string[]): OperatorFunction<EntityAction, T>;
+
+declare enum ChangeSetOperation {
+    Add = "Add",
+    Delete = "Delete",
+    Update = "Update",
+    Upsert = "Upsert"
+}
+interface ChangeSetAdd<T = any> {
+    op: ChangeSetOperation.Add;
+    entityName: string;
+    entities: T[];
+}
+interface ChangeSetDelete {
+    op: ChangeSetOperation.Delete;
+    entityName: string;
+    entities: string[] | number[];
+}
+interface ChangeSetUpdate<T = any> {
+    op: ChangeSetOperation.Update;
+    entityName: string;
+    entities: Update<T>[];
+}
+interface ChangeSetUpsert<T = any> {
+    op: ChangeSetOperation.Upsert;
+    entityName: string;
+    entities: T[];
+}
+/**
+ * A entities of a single entity type, which are changed in the same way by a ChangeSetOperation
+ */
+type ChangeSetItem = ChangeSetAdd | ChangeSetDelete | ChangeSetUpdate | ChangeSetUpsert;
+interface ChangeSet<T = any> {
+    /** An array of ChangeSetItems to be processed in the array order */
+    changes: ChangeSetItem[];
+    /**
+     * An arbitrary, serializable object that should travel with the ChangeSet.
+     * Meaningful to the ChangeSet producer and consumer. Ignored by @ngrx/data.
+     */
+    extras?: T;
+    /** An arbitrary string, identifying the ChangeSet and perhaps its purpose */
+    tag?: string;
+}
+/**
+ * Factory to create a ChangeSetItem for a ChangeSetOperation
+ */
+declare class ChangeSetItemFactory {
+    /** Create the ChangeSetAdd for new entities of the given entity type */
+    add<T>(entityName: string, entities: T | T[]): ChangeSetAdd<T>;
+    /** Create the ChangeSetDelete for primary keys of the given entity type */
+    delete(entityName: string, keys: number | number[] | string | string[]): ChangeSetDelete;
+    /** Create the ChangeSetUpdate for Updates of entities of the given entity type */
+    update<T extends {
+        id: string | number;
+    }>(entityName: string, updates: Update<T> | Update<T>[]): ChangeSetUpdate<T>;
+    /** Create the ChangeSetUpsert for new or existing entities of the given entity type */
+    upsert<T>(entityName: string, entities: T | T[]): ChangeSetUpsert<T>;
+}
+/**
+ * Instance of a factory to create a ChangeSetItem for a ChangeSetOperation
+ */
+declare const changeSetItemFactory: ChangeSetItemFactory;
+/**
+ * Return ChangeSet after filtering out null and empty ChangeSetItems.
+ * @param changeSet ChangeSet with changes to filter
+ */
+declare function excludeEmptyChangeSetItems(changeSet: ChangeSet): ChangeSet;
+
+/**
+ * Error from a DataService
+ * The source error either comes from a failed HTTP response or was thrown within the service.
+ * @param error the HttpErrorResponse or the error thrown by the service
+ * @param requestData the HTTP request information such as the method and the url.
+ */
+declare class DataServiceError extends Error {
+    error: any;
+    requestData: RequestData | null;
+    constructor(error: any, requestData: RequestData | null);
+}
+/** Payload for an EntityAction data service error such as QUERY_ALL_ERROR */
+interface EntityActionDataServiceError {
+    error: DataServiceError;
+    originalAction: EntityAction;
+}
+
+/** Types of change in a ChangeState instance */
+declare enum ChangeType {
+    /** The entity has not changed from its last known server state. */
+    Unchanged = 0,
+    /** The entity was added to the collection */
+    Added = 1,
+    /** The entity is scheduled for delete and was removed from the collection */
+    Deleted = 2,
+    /** The entity in the collection was updated */
+    Updated = 3
+}
+/**
+ * Change state for an entity with unsaved changes;
+ * an entry in an EntityCollection.changeState map
+ */
+interface ChangeState<T> {
+    changeType: ChangeType;
+    originalValue?: T | undefined;
+}
+/**
+ * Map of entity primary keys to entity ChangeStates.
+ * Each entry represents an entity with unsaved changes.
+ */
+type ChangeStateMap<T> = Dictionary<ChangeState<T>>;
+/**
+ * Data and information about a collection of entities of a single type.
+ * EntityCollections are maintained in the EntityCache within the ngrx store.
+ */
+interface EntityCollection<T = any> extends EntityState<T> {
+    /** Name of the entity type for this collection */
+    entityName: string;
+    /** A map of ChangeStates, keyed by id, for entities with unsaved changes */
+    changeState: ChangeStateMap<T>;
+    /** The user's current collection filter pattern */
+    filter?: string;
+    /** true if collection was ever filled by QueryAll; forced false if cleared */
+    loaded: boolean;
+    /** true when a query or save operation is in progress */
+    loading: boolean;
+}
+
+interface EntityCache {
+    [name: string]: EntityCollection<any>;
+}
+
+declare enum EntityCacheAction {
+    CLEAR_COLLECTIONS = "@ngrx/data/entity-cache/clear-collections",
+    LOAD_COLLECTIONS = "@ngrx/data/entity-cache/load-collections",
+    MERGE_QUERY_SET = "@ngrx/data/entity-cache/merge-query-set",
+    SET_ENTITY_CACHE = "@ngrx/data/entity-cache/set-cache",
+    SAVE_ENTITIES = "@ngrx/data/entity-cache/save-entities",
+    SAVE_ENTITIES_CANCEL = "@ngrx/data/entity-cache/save-entities-cancel",
+    SAVE_ENTITIES_CANCELED = "@ngrx/data/entity-cache/save-entities-canceled",
+    SAVE_ENTITIES_ERROR = "@ngrx/data/entity-cache/save-entities-error",
+    SAVE_ENTITIES_SUCCESS = "@ngrx/data/entity-cache/save-entities-success"
+}
+/**
+ * Hash of entities keyed by EntityCollection name,
+ * typically the result of a query that returned results from a multi-collection query
+ * that will be merged into an EntityCache via the `MergeQuerySet` action.
+ */
+interface EntityCacheQuerySet {
+    [entityName: string]: any[];
+}
+/**
+ * Clear the collections identified in the collectionSet.
+ * @param [collections] Array of names of the collections to clear.
+ * If empty array, does nothing. If no array, clear all collections.
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+declare class ClearCollections implements Action {
+    readonly payload: {
+        collections?: string[];
+        tag?: string;
+    };
+    readonly type = EntityCacheAction.CLEAR_COLLECTIONS;
+    constructor(collections?: string[], tag?: string);
+}
+/**
+ * Create entity cache action that loads multiple entity collections at the same time.
+ * before any selectors$ observables emit.
+ * @param querySet The collections to load, typically the result of a query.
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ * in the form of a map of entity collections.
+ */
+declare class LoadCollections implements Action {
+    readonly payload: {
+        collections: EntityCacheQuerySet;
+        tag?: string;
+    };
+    readonly type = EntityCacheAction.LOAD_COLLECTIONS;
+    constructor(collections: EntityCacheQuerySet, tag?: string);
+}
+/**
+ * Create entity cache action that merges entities from a query result
+ * that returned entities from multiple collections.
+ * Corresponding entity cache reducer should add and update all collections
+ * at the same time, before any selectors$ observables emit.
+ * @param querySet The result of the query in the form of a map of entity collections.
+ * These are the entity data to merge into the respective collections.
+ * @param mergeStrategy How to merge a queried entity when it is already in the collection.
+ * The default is MergeStrategy.PreserveChanges
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+declare class MergeQuerySet implements Action {
+    readonly payload: {
+        querySet: EntityCacheQuerySet;
+        mergeStrategy?: MergeStrategy;
+        tag?: string;
+    };
+    readonly type = EntityCacheAction.MERGE_QUERY_SET;
+    constructor(querySet: EntityCacheQuerySet, mergeStrategy?: MergeStrategy, tag?: string);
+}
+/**
+ * Create entity cache action for replacing the entire entity cache.
+ * Dangerous because brute force but useful as when re-hydrating an EntityCache
+ * from local browser storage when the application launches.
+ * @param cache New state of the entity cache
+ * @param [tag] Optional tag to identify the operation from the app perspective.
+ */
+declare class SetEntityCache implements Action {
+    readonly cache: EntityCache;
+    readonly payload: {
+        cache: EntityCache;
+        tag?: string;
+    };
+    readonly type = EntityCacheAction.SET_ENTITY_CACHE;
+    constructor(cache: EntityCache, tag?: string);
+}
+declare class SaveEntities implements Action {
+    readonly payload: {
+        readonly changeSet: ChangeSet;
+        readonly url: string;
+        readonly correlationId?: any;
+        readonly isOptimistic?: boolean;
+        readonly mergeStrategy?: MergeStrategy;
+        readonly tag?: string;
+        error?: Error;
+        skip?: boolean;
+    };
+    readonly type = EntityCacheAction.SAVE_ENTITIES;
+    constructor(changeSet: ChangeSet, url: string, options?: EntityActionOptions);
+}
+declare class SaveEntitiesCancel implements Action {
+    readonly payload: {
+        readonly correlationId: any;
+        readonly reason?: string;
+        readonly entityNames?: string[];
+        readonly tag?: string;
+    };
+    readonly type = EntityCacheAction.SAVE_ENTITIES_CANCEL;
+    constructor(correlationId: any, reason?: string, entityNames?: string[], tag?: string);
+}
+declare class SaveEntitiesCanceled implements Action {
+    readonly payload: {
+        readonly correlationId: any;
+        readonly reason?: string;
+        readonly tag?: string;
+    };
+    readonly type = EntityCacheAction.SAVE_ENTITIES_CANCELED;
+    constructor(correlationId: any, reason?: string, tag?: string);
+}
+declare class SaveEntitiesError {
+    readonly payload: {
+        readonly error: DataServiceError;
+        readonly originalAction: SaveEntities;
+        readonly correlationId: any;
+    };
+    readonly type = EntityCacheAction.SAVE_ENTITIES_ERROR;
+    constructor(error: DataServiceError, originalAction: SaveEntities);
+}
+declare class SaveEntitiesSuccess implements Action {
+    readonly payload: {
+        readonly changeSet: ChangeSet;
+        readonly url: string;
+        readonly correlationId?: any;
+        readonly isOptimistic?: boolean;
+        readonly mergeStrategy?: MergeStrategy;
+        readonly tag?: string;
+        error?: Error;
+        skip?: boolean;
+    };
+    readonly type = EntityCacheAction.SAVE_ENTITIES_SUCCESS;
+    constructor(changeSet: ChangeSet, url: string, options?: EntityActionOptions);
+}
+
+declare abstract class Logger {
+    abstract error(message?: any, ...optionalParams: any[]): void;
+    abstract log(message?: any, ...optionalParams: any[]): void;
+    abstract warn(message?: any, ...optionalParams: any[]): void;
+}
+/**
+ * Mapping of entity type name to its plural
+ */
+interface EntityPluralNames {
+    [entityName: string]: string;
+}
+declare const PLURAL_NAMES_TOKEN: InjectionToken<EntityPluralNames>;
+declare abstract class Pluralizer {
+    abstract pluralize(name: string): string;
+}
+
+/**
+ * Known resource URLS for specific entity types.
+ * Each entity's resource URLS are endpoints that
+ * target single entity and multi-entity HTTP operations.
+ * Used by the `DefaultHttpUrlGenerator`.
+ */
+declare abstract class EntityHttpResourceUrls {
+    [entityName: string]: HttpResourceUrls;
+}
+/**
+ * Resource URLS for HTTP operations that target single entity
+ * and multi-entity endpoints.
+ */
+interface HttpResourceUrls {
+    /**
+     * The URL path for a single entity endpoint, e.g, `some-api-root/hero/`
+     * such as you'd use to add a hero.
+     * Example: `httpClient.post<Hero>('some-api-root/hero/', addedHero)`.
+     * Note trailing slash (/).
+     */
+    entityResourceUrl: string;
+    /**
+     * The URL path for a multiple-entity endpoint, e.g, `some-api-root/heroes/`
+     * such as you'd use when getting all heroes.
+     * Example: `httpClient.get<Hero[]>('some-api-root/heroes/')`
+     * Note trailing slash (/).
+     */
+    collectionResourceUrl: string;
+}
+/**
+ * Generate the base part of an HTTP URL for
+ * single entity or entity collection resource
+ */
+declare abstract class HttpUrlGenerator {
+    /**
+     * Return the base URL for a single entity resource,
+     * e.g., the base URL to get a single hero by its id
+     */
+    abstract entityResource(entityName: string, root: string, trailingSlashEndpoints: boolean): string;
+    /**
+     * Return the base URL for a collection resource,
+     * e.g., the base URL to get all heroes
+     */
+    abstract collectionResource(entityName: string, root: string): string;
+    /**
+     * Register known single-entity and collection resource URLs for HTTP calls
+     * @param entityHttpResourceUrls {EntityHttpResourceUrls} resource urls for specific entity type names
+     */
+    abstract registerHttpResourceUrls(entityHttpResourceUrls?: EntityHttpResourceUrls): void;
+}
+declare class DefaultHttpUrlGenerator implements HttpUrlGenerator {
+    private pluralizer;
+    /**
+     * Known single-entity and collection resource URLs for HTTP calls.
+     * Generator methods returns these resource URLs for a given entity type name.
+     * If the resources for an entity type name are not know, it generates
+     * and caches a resource name for future use
+     */
+    protected knownHttpResourceUrls: EntityHttpResourceUrls;
+    constructor(pluralizer: Pluralizer);
+    /**
+     * Get or generate the entity and collection resource URLs for the given entity type name
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     */
+    protected getResourceUrls(entityName: string, root: string, trailingSlashEndpoints?: boolean): HttpResourceUrls;
+    /**
+     * Create the path to a single entity resource
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     * @returns complete path to resource, e.g, 'some-api/hero'
+     */
+    entityResource(entityName: string, root: string, trailingSlashEndpoints: boolean): string;
+    /**
+     * Create the path to a multiple entity (collection) resource
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     * @returns complete path to resource, e.g, 'some-api/heroes'
+     */
+    collectionResource(entityName: string, root: string): string;
+    /**
+     * Register known single-entity and collection resource URLs for HTTP calls
+     * @param entityHttpResourceUrls {EntityHttpResourceUrls} resource urls for specific entity type names
+     * Well-formed resource urls end in a '/';
+     * Note: this method does not ensure that resource urls are well-formed.
+     */
+    registerHttpResourceUrls(entityHttpResourceUrls: EntityHttpResourceUrls): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultHttpUrlGenerator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultHttpUrlGenerator>;
+}
+/** Remove leading & trailing spaces or slashes */
+declare function normalizeRoot(root: string): string;
+
+/**
+ * Optional configuration settings for an entity collection data service
+ * such as the `DefaultDataService<T>`.
+ */
+declare abstract class DefaultDataServiceConfig {
+    /**
+     * root path of the web api.  may also include protocol, domain, and port
+     * for remote api, e.g.: `'https://api-domain.com:8000/api/v1'` (default: 'api')
+     */
+    root?: string;
+    /**
+     * Known entity HttpResourceUrls.
+     * HttpUrlGenerator will create these URLs for entity types not listed here.
+     */
+    entityHttpResourceUrls?: EntityHttpResourceUrls;
+    /** Is a DELETE 404 really OK? (default: true) */
+    delete404OK?: boolean;
+    /** Simulate GET latency in a demo (default: 0) */
+    getDelay?: number;
+    /** Simulate save method (PUT/POST/DELETE) latency in a demo (default: 0) */
+    saveDelay?: number;
+    /** request timeout in MS (default: 0)*/
+    timeout?: number;
+    /** to keep leading & trailing slashes or not; false by default */
+    trailingSlashEndpoints?: boolean;
+}
+
+/**
+ * A basic, generic entity data service
+ * suitable for persistence of most entities.
+ * Assumes a common REST-y web API
+ */
+declare class DefaultDataService<T> implements EntityCollectionDataService<T> {
+    protected http: HttpClient;
+    protected httpUrlGenerator: HttpUrlGenerator;
+    protected _name: string;
+    protected delete404OK: boolean;
+    protected entityName: string;
+    protected entityUrl: string;
+    protected entitiesUrl: string;
+    protected getDelay: number;
+    protected saveDelay: number;
+    protected timeout: number;
+    protected trailingSlashEndpoints: boolean;
+    get name(): string;
+    constructor(entityName: string, http: HttpClient, httpUrlGenerator: HttpUrlGenerator, config?: DefaultDataServiceConfig);
+    add(entity: T, options?: HttpOptions): Observable<T>;
+    delete(key: number | string, options?: HttpOptions): Observable<number | string>;
+    getAll(options?: HttpOptions): Observable<T[]>;
+    getById(key: number | string, options?: HttpOptions): Observable<T>;
+    getWithQuery(queryParams: QueryParams | string | undefined, options?: HttpOptions): Observable<T[]>;
+    update(update: Update<T>, options?: HttpOptions): Observable<T>;
+    upsert(entity: T, options?: HttpOptions): Observable<T>;
+    protected execute(method: HttpMethods, url: string, data?: any, // data, error, or undefined/null
+    options?: any, // options or undefined/null
+    httpOptions?: HttpOptions): Observable<any>;
+    private handleError;
+    private handleDelete404;
+}
+/**
+ * Create a basic, generic entity data service
+ * suitable for persistence of most entities.
+ * Assumes a common REST-y web API
+ */
+declare class DefaultDataServiceFactory {
+    protected http: HttpClient;
+    protected httpUrlGenerator: HttpUrlGenerator;
+    protected config?: DefaultDataServiceConfig;
+    constructor(http: HttpClient, httpUrlGenerator: HttpUrlGenerator, config?: DefaultDataServiceConfig);
+    /**
+     * Create a default {EntityCollectionDataService} for the given entity type
+     * @param entityName {string} Name of the entity type for this data service
+     */
+    create<T>(entityName: string): EntityCollectionDataService<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDataServiceFactory, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultDataServiceFactory>;
+}
+
+/**
+ * Default options for EntityDispatcher behavior
+ * such as whether `add()` is optimistic or pessimistic by default.
+ * An optimistic save modifies the collection immediately and before saving to the server.
+ * A pessimistic save modifies the collection after the server confirms the save was successful.
+ * This class initializes the defaults to the safest values.
+ * Provide an alternative to change the defaults for all entity collections.
+ */
+declare class EntityDispatcherDefaultOptions {
+    /** True if added entities are saved optimistically; false if saved pessimistically. */
+    optimisticAdd: boolean;
+    /** True if deleted entities are saved optimistically; false if saved pessimistically. */
+    optimisticDelete: boolean;
+    /** True if updated entities are saved optimistically; false if saved pessimistically. */
+    optimisticUpdate: boolean;
+    /** True if upsert entities are saved optimistically; false if saved pessimistically. */
+    optimisticUpsert: boolean;
+    /** True if entities in a cache saveEntities request are saved optimistically; false if saved pessimistically. */
+    optimisticSaveEntities: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDispatcherDefaultOptions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityDispatcherDefaultOptions>;
+}
+
+/**
+ * Filters the `entities` array argument and returns the original `entities`,
+ * or a new filtered array of entities.
+ * NEVER mutate the original `entities` array itself.
+ **/
+type EntityFilterFn<T> = (entities: T[], pattern?: any) => T[];
+/**
+ * Creates an {EntityFilterFn} that matches RegExp or RegExp string pattern
+ * anywhere in any of the given props of an entity.
+ * If pattern is a string, spaces are significant and ignores case.
+ */
+declare function PropsFilterFnFactory<T = any>(props?: (keyof T)[]): EntityFilterFn<T>;
+
+declare const ENTITY_METADATA_TOKEN: InjectionToken<EntityMetadataMap>;
+/** Metadata that describe an entity type and its collection to @ngrx/data */
+interface EntityMetadata<T = any, S extends object = {}> {
+    entityName: string;
+    entityDispatcherOptions?: Partial<EntityDispatcherDefaultOptions>;
+    filterFn?: EntityFilterFn<T>;
+    noChangeTracking?: boolean;
+    selectId?: IdSelector<T>;
+    sortComparer?: false | Comparer<T>;
+    additionalCollectionState?: S;
+}
+/** Map entity-type name to its EntityMetadata */
+interface EntityMetadataMap {
+    [entityName: string]: Partial<EntityMetadata<any>>;
+}
+
+interface EntityDefinition<T = any> {
+    entityName: string;
+    entityAdapter: EntityAdapter<T>;
+    entityDispatcherOptions?: Partial<EntityDispatcherDefaultOptions>;
+    initialState: EntityCollection<T>;
+    metadata: EntityMetadata<T>;
+    noChangeTracking: boolean;
+    selectId: IdSelector<T>;
+    sortComparer: false | Comparer<T>;
+}
+declare function createEntityDefinition<T, S extends object>(metadata: EntityMetadata<T, S>): EntityDefinition<T>;
+
+interface EntityDefinitions {
+    [entityName: string]: EntityDefinition<any>;
+}
+/** Registry of EntityDefinitions for all cached entity types */
+declare class EntityDefinitionService {
+    /** {EntityDefinition} for all cached entity types */
+    private readonly definitions;
+    constructor(entityMetadataMaps: EntityMetadataMap[]);
+    /**
+     * Get (or create) a data service for entity type
+     * @param entityName - the name of the type
+     *
+     * Examples:
+     *   getDefinition('Hero'); // definition for Heroes, untyped
+     *   getDefinition<Hero>(`Hero`); // definition for Heroes, typed with Hero interface
+     */
+    getDefinition<T>(entityName: string, shouldThrow?: boolean): EntityDefinition<T>;
+    /**
+     * Create and register the {EntityDefinition} for the {EntityMetadata} of an entity type
+     * @param name - the name of the entity type
+     * @param definition - {EntityMetadata} for a collection for that entity type
+     *
+     * Examples:
+     *   registerMetadata(myHeroEntityDefinition);
+     */
+    registerMetadata(metadata: EntityMetadata): void;
+    /**
+     * Register an EntityMetadataMap.
+     * @param metadataMap - a map of entityType names to entity metadata
+     *
+     * Examples:
+     *   registerMetadataMap({
+     *     'Hero': myHeroMetadata,
+     *     Villain: myVillainMetadata
+     *   });
+     */
+    registerMetadataMap(metadataMap?: EntityMetadataMap): void;
+    /**
+     * Register an {EntityDefinition} for an entity type
+     * @param definition - EntityDefinition of a collection for that entity type
+     *
+     * Examples:
+     *   registerDefinition('Hero', myHeroEntityDefinition);
+     */
+    registerDefinition<T>(definition: EntityDefinition<T>): void;
+    /**
+     * Register a batch of EntityDefinitions.
+     * @param definitions - map of entityType name and associated EntityDefinitions to merge.
+     *
+     * Examples:
+     *   registerDefinitions({
+     *     'Hero': myHeroEntityDefinition,
+     *     Villain: myVillainEntityDefinition
+     *   });
+     */
+    registerDefinitions(definitions: EntityDefinitions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDefinitionService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityDefinitionService>;
+}
+
+/**
+ * Default data service for making remote service calls targeting the entire EntityCache.
+ * See EntityDataService for services that target a single EntityCollection
+ */
+declare class EntityCacheDataService {
+    protected entityDefinitionService: EntityDefinitionService;
+    protected http: HttpClient;
+    protected idSelectors: {
+        [entityName: string]: IdSelector<any>;
+    };
+    protected saveDelay: number;
+    protected timeout: number;
+    constructor(entityDefinitionService: EntityDefinitionService, http: HttpClient, config?: DefaultDataServiceConfig);
+    /**
+     * Save changes to multiple entities across one or more entity collections.
+     * Server endpoint must understand the essential SaveEntities protocol,
+     * in particular the ChangeSet interface (except for Update<T>).
+     * This implementation extracts the entity changes from a ChangeSet Update<T>[] and sends those.
+     * It then reconstructs Update<T>[] in the returned observable result.
+     * @param changeSet  An array of SaveEntityItems.
+     * Each SaveEntityItem describe a change operation for one or more entities of a single collection,
+     * known by its 'entityName'.
+     * @param url The server endpoint that receives this request.
+     */
+    saveEntities(changeSet: ChangeSet, url: string): Observable<ChangeSet>;
+    protected handleError(reqData: RequestData): (err: any) => Observable<never>;
+    /**
+     * Filter changeSet to remove unwanted ChangeSetItems.
+     * This implementation excludes null and empty ChangeSetItems.
+     * @param changeSet ChangeSet with changes to filter
+     */
+    protected filterChangeSet(changeSet: ChangeSet): ChangeSet;
+    /**
+     * Convert the entities in update changes from @ngrx Update<T> structure to just T.
+     * Reverse of restoreUpdates().
+     */
+    protected flattenUpdates(changeSet: ChangeSet): ChangeSet;
+    /**
+     * Convert the flattened T entities in update changes back to @ngrx Update<T> structures.
+     * Reverse of flattenUpdates().
+     */
+    protected restoreUpdates(changeSet: ChangeSet): ChangeSet;
+    /**
+     * Get the id (primary key) selector function for an entity type
+     * @param entityName name of the entity type
+     */
+    protected getIdSelector(entityName: string): IdSelector<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCacheDataService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCacheDataService>;
+}
+
+/**
+ * Registry of EntityCollection data services that make REST-like CRUD calls
+ * to entity collection endpoints.
+ */
+declare class EntityDataService {
+    protected defaultDataServiceFactory: DefaultDataServiceFactory;
+    protected services: {
+        [name: string]: EntityCollectionDataService<any>;
+    };
+    constructor(defaultDataServiceFactory: DefaultDataServiceFactory);
+    /**
+     * Get (or create) a data service for entity type
+     * @param entityName - the name of the type
+     *
+     * Examples:
+     *   getService('Hero'); // data service for Heroes, untyped
+     *   getService<Hero>('Hero'); // data service for Heroes, typed as Hero
+     */
+    getService<T>(entityName: string): EntityCollectionDataService<T>;
+    /**
+     * Register an EntityCollectionDataService for an entity type
+     * @param entityName - the name of the entity type
+     * @param service - data service for that entity type
+     *
+     * Examples:
+     *   registerService('Hero', myHeroDataService);
+     *   registerService('Villain', myVillainDataService);
+     */
+    registerService<T>(entityName: string, service: EntityCollectionDataService<T>): void;
+    /**
+     * Register a batch of data services.
+     * @param services - data services to merge into existing services
+     *
+     * Examples:
+     *   registerServices({
+     *     Hero: myHeroDataService,
+     *     Villain: myVillainDataService
+     *   });
+     */
+    registerServices(services: {
+        [name: string]: EntityCollectionDataService<any>;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityDataService>;
+}
+
+/**
+ * Handling of responses from persistence operation
+ */
+declare abstract class PersistenceResultHandler {
+    /** Handle successful result of persistence operation for an action */
+    abstract handleSuccess(originalAction: EntityAction): (data: any) => Action;
+    /** Handle error result of persistence operation for an action */
+    abstract handleError(originalAction: EntityAction): (error: DataServiceError | Error) => EntityAction<EntityActionDataServiceError>;
+}
+/**
+ * Default handling of responses from persistence operation,
+ * specifically an EntityDataService
+ */
+declare class DefaultPersistenceResultHandler implements PersistenceResultHandler {
+    private logger;
+    private entityActionFactory;
+    constructor(logger: Logger, entityActionFactory: EntityActionFactory);
+    /** Handle successful result of persistence operation on an EntityAction */
+    handleSuccess(originalAction: EntityAction): (data: any) => Action;
+    /** Handle error result of persistence operation on an EntityAction */
+    handleError(originalAction: EntityAction): (error: DataServiceError | Error) => EntityAction<EntityActionDataServiceError>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultPersistenceResultHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultPersistenceResultHandler>;
+}
+
+/**
+ * Generates a string id beginning 'CRID',
+ * followed by a monotonically increasing integer for use as a correlation id.
+ * As they are produced locally by a singleton service,
+ * these ids are guaranteed to be unique only
+ * for the duration of a single client browser instance.
+ * Ngrx entity dispatcher query and save methods call this service to generate default correlation ids.
+ * Do NOT use for entity keys.
+ */
+declare class CorrelationIdGenerator {
+    /** Seed for the ids */
+    protected seed: number;
+    /** Prefix of the id, 'CRID; */
+    protected prefix: string;
+    /** Return the next correlation id */
+    next(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CorrelationIdGenerator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CorrelationIdGenerator>;
+}
+
+/**
+ * Dispatches Entity Cache actions to the EntityCache reducer
+ */
+declare class EntityCacheDispatcher {
+    /** Generates correlation ids for query and save methods */
+    private correlationIdGenerator;
+    /**
+     * Dispatcher options configure dispatcher behavior such as
+     * whether add is optimistic or pessimistic by default.
+     */
+    private defaultDispatcherOptions;
+    /** The store, scoped to the EntityCache */
+    private store;
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent action reduced by the store.
+     */
+    reducedActions$: Observable<Action>;
+    private raSubscription;
+    constructor(
+    /** Generates correlation ids for query and save methods */
+    correlationIdGenerator: CorrelationIdGenerator, 
+    /**
+     * Dispatcher options configure dispatcher behavior such as
+     * whether add is optimistic or pessimistic by default.
+     */
+    defaultDispatcherOptions: EntityDispatcherDefaultOptions, 
+    /** Actions scanned by the store after it processed them with reducers. */
+    scannedActions$: Observable<Action>, 
+    /** The store, scoped to the EntityCache */
+    store: Store<EntityCache>);
+    /**
+     * Dispatch an Action to the store.
+     * @param action the Action
+     * @returns the dispatched Action
+     */
+    dispatch(action: Action): Action;
+    /**
+     * Dispatch action to cancel the saveEntities request with matching correlation id.
+     * @param correlationId The correlation id for the corresponding action
+     * @param [reason] explains why canceled and by whom.
+     * @param [entityNames] array of entity names so can turn off loading flag for their collections.
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    cancelSaveEntities(correlationId: any, reason?: string, entityNames?: string[], tag?: string): void;
+    /** Clear the named entity collections in cache
+     * @param [collections] Array of names of the collections to clear.
+     * If empty array, does nothing. If null/undefined/no array, clear all collections.
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    clearCollections(collections?: string[], tag?: string): void;
+    /**
+     * Load multiple entity collections at the same time.
+     * before any selectors$ observables emit.
+     * @param collections The collections to load, typically the result of a query.
+     * @param [tag] tag to identify the operation from the app perspective.
+     * in the form of a map of entity collections.
+     */
+    loadCollections(collections: EntityCacheQuerySet, tag?: string): void;
+    /**
+     * Merges entities from a query result
+     * that returned entities from multiple collections.
+     * Corresponding entity cache reducer should add and update all collections
+     * at the same time, before any selectors$ observables emit.
+     * @param querySet The result of the query in the form of a map of entity collections.
+     * These are the entity data to merge into the respective collections.
+     * @param mergeStrategy How to merge a queried entity when it is already in the collection.
+     * The default is MergeStrategy.PreserveChanges
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    mergeQuerySet(querySet: EntityCacheQuerySet, mergeStrategy?: MergeStrategy, tag?: string): void;
+    /**
+     * Create entity cache action for replacing the entire entity cache.
+     * Dangerous because brute force but useful as when re-hydrating an EntityCache
+     * from local browser storage when the application launches.
+     * @param cache New state of the entity cache
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    setEntityCache(cache: EntityCache, tag?: string): void;
+    /**
+     * Dispatch action to save multiple entity changes to remote storage.
+     * Relies on an Ngrx Effect such as EntityEffects.saveEntities$.
+     * Important: only call if your server supports the SaveEntities protocol
+     * through your EntityDataService.saveEntities method.
+     * @param changes Either the entities to save, as an array of {ChangeSetItem}, or
+     * a ChangeSet that holds such changes.
+     * @param url The server url which receives the save request
+     * @param [options] options such as tag, correlationId, isOptimistic, and mergeStrategy.
+     * These values are defaulted if not supplied.
+     * @returns A terminating Observable<ChangeSet> with data returned from the server
+     * after server reports successful save OR the save error.
+     * TODO: should return the matching entities from cache rather than the raw server data.
+     */
+    saveEntities(changes: ChangeSetItem[] | ChangeSet, url: string, options?: EntityActionOptions): Observable<ChangeSet>;
+    /**
+     * Return Observable of data from the server-success SaveEntities action with
+     * the given Correlation Id, after that action was processed by the ngrx store.
+     * or else put the server error on the Observable error channel.
+     * @param crid The correlationId for both the save and response actions.
+     */
+    private getSaveEntitiesResponseData$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCacheDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCacheDispatcher>;
+}
+
+/** Commands that update the remote server. */
+interface EntityServerCommands<T> {
+    /**
+     * Dispatch action to save a new entity to remote storage.
+     * @param entity entity to add, which may omit its key if pessimistic and the server creates the key;
+     * must have a key if optimistic save.
+     * @returns A terminating Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    add(entity: Partial<T>, options?: EntityActionOptions & {
+        isOptimistic?: false;
+    }): Observable<T>;
+    add(entity: T, options: EntityActionOptions & {
+        isOptimistic: true;
+    }): Observable<T>;
+    add(entity: T, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to cancel the persistence operation (query or save) with the given correlationId.
+     * @param correlationId The correlation id for the corresponding EntityAction
+     * @param [reason] explains why canceled and by whom.
+     * @param [options] options such as the tag
+     */
+    cancel(correlationId: any, reason?: string, options?: EntityActionOptions): void;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The entity to delete
+     * @param [options] options that influence save and merge behavior
+     * @returns A terminating Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(entity: T, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The primary key of the entity to remove
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(key: number | string, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * merge the queried entities into the cached collection.
+     * @param [options] options that influence merge behavior
+     * @returns A terminating Observable of the collection
+     * after server reports successful query or the query error.
+     * @see load()
+     */
+    getAll(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entity with this primary key.
+     * If the server returns an entity,
+     * merge it into the cached collection.
+     * @param key The primary key of the entity to get.
+     * @param [options] options that influence merge behavior
+     * @returns A terminating Observable of the queried entities that are in the collection
+     * after server reports success or the query error.
+     */
+    getByKey(key: any, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string,
+     * and merge the results into the cached collection.
+     * @param queryParams the query in a form understood by the server
+     * @param [options] options that influence merge behavior
+     * @returns A terminating Observable of the queried entities
+     * after server reports successful query or the query error.
+     */
+    getWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * completely replace the cached collection with the queried entities.
+     * @param [options] options that influence load behavior
+     * @returns A terminating Observable of the entities in the collection
+     * after server reports successful query or the query error.
+     * @see getAll
+     */
+    load(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string, and
+     * completely replace the cached collection with the queried entities.
+     * @param queryParams the query in a form understood by the server
+     * @param [options] options that influence load behavior
+     * @returns A terminating Observable of the entities in the collection
+     * after server reports successful query or the query error.
+     * @see getWithQuery
+     */
+    loadWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to save the updated entity (or partial entity) in remote storage.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     * @param entity update entity, which might be a partial of T but must at least have its key.
+     * @param [options] options that influence save and merge behavior
+     * @returns A terminating Observable of the updated entity
+     * after server reports successful save or the save error.
+     */
+    update(entity: Partial<T>, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to save a new or update an existing entity to remote storage.
+     * Only dispatch this action if your server supports upsert.
+     * @param entity entity to upsert, which may omit its key if pessimistic and the server creates the key;
+     * must have a key if optimistic save.
+     * @returns A terminating Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    upsert(entity: T, options?: EntityActionOptions): Observable<T>;
+}
+/*** A collection's cache-only commands, which do not update remote storage ***/
+interface EntityCacheCommands<T> {
+    /**
+     * Replace all entities in the cached collection.
+     * Does not save to remote storage.
+     * @param entities to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addAllToCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Add a new entity directly to the cache.
+     * Does not save to remote storage.
+     * Ignored if an entity with the same primary key is already in cache.
+     * @param entity to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addOneToCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Add multiple new entities directly to the cache.
+     * Does not save to remote storage.
+     * Entities with primary keys already in cache are ignored.
+     * @param entities to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addManyToCache(entities: T[], options?: EntityActionOptions): void;
+    /** Clear the cached entity collection */
+    clearCache(options?: EntityActionOptions): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param entity The entity to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeOneFromCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param key The primary key of the entity to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeOneFromCache(key: number | string, options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param entity The entities to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeManyFromCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param keys The primary keys of the entities to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeManyFromCache(keys: (number | string)[], options?: EntityActionOptions): void;
+    /**
+     * Update a cached entity directly.
+     * Does not update that entity in remote storage.
+     * Ignored if an entity with matching primary key is not in cache.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     * @param entity to update directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    updateOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Update multiple cached entities directly.
+     * Does not update these entities in remote storage.
+     * Entities whose primary keys are not in cache are ignored.
+     * Update entities may be partial but must at least have their keys.
+     * such partial entities patch their cached counterparts.
+     * @param entities to update directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    updateManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Insert or update a cached entity directly.
+     * Does not save to remote storage.
+     * Upsert entity might be a partial of T but must at least have its key.
+     * Pass the Update<T> structure as the payload.
+     * @param entity to upsert directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    upsertOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Insert or update multiple cached entities directly.
+     * Does not save to remote storage.
+     * Upsert entities might be partial but must at least have their keys.
+     * Pass an array of the Update<T> structure as the payload.
+     * @param entities to upsert directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    upsertManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Set the pattern that the collection's filter applies
+     * when using the `filteredEntities` selector.
+     */
+    setFilter(pattern: any, options?: EntityActionOptions): void;
+    /** Set the loaded flag */
+    setLoaded(isLoaded: boolean, options?: EntityActionOptions): void;
+    /** Set the loading flag */
+    setLoading(isLoading: boolean, options?: EntityActionOptions): void;
+}
+/** Commands that dispatch entity actions for a collection */
+interface EntityCommands<T> extends EntityServerCommands<T>, EntityCacheCommands<T> {
+}
+
+declare const ENTITY_CACHE_SELECTOR_TOKEN: InjectionToken<MemoizedSelector<Object, EntityCache, _ngrx_store.DefaultProjectorFn<EntityCache>>>;
+declare const entityCacheSelectorProvider: FactoryProvider;
+type EntityCacheSelector = MemoizedSelector<Object, EntityCache>;
+declare function createEntityCacheSelector(entityCacheName?: string): MemoizedSelector<Object, EntityCache>;
+
+/**
+ * Dispatches EntityCollection actions to their reducers and effects.
+ * The substance of the interface is in EntityCommands.
+ */
+interface EntityDispatcher<T> extends EntityCommands<T> {
+    /** Name of the entity type */
+    readonly entityName: string;
+    /**
+     * Utility class with methods to validate EntityAction payloads.
+     */
+    readonly guard: EntityActionGuard<T>;
+    /** Returns the primary key (id) of this entity */
+    readonly selectId: IdSelector<T>;
+    /** Returns the store, scoped to the EntityCache */
+    readonly store: Store<EntityCache>;
+    /**
+     * Create an {EntityAction} for this entity type.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the EntityAction
+     */
+    createEntityAction<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Create an {EntityAction} for this entity type and
+     * dispatch it immediately to the store.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the dispatched EntityAction
+     */
+    createAndDispatch<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Dispatch an Action to the store.
+     * @param action the Action
+     * @returns the dispatched Action
+     */
+    dispatch(action: Action): Action;
+    /**
+     * Convert an entity (or partial entity) into the `Update<T>` object
+     * `update...` and `upsert...` methods take `Update<T>` args
+     */
+    toUpdate(entity: Partial<T>): Update<T>;
+}
+/**
+ * Persistence operation canceled
+ */
+declare class PersistanceCanceled {
+    readonly message?: string;
+    constructor(message?: string);
+}
+
+/**
+ * Dispatches EntityCollection actions to their reducers and effects (default implementation).
+ * All save commands rely on an Ngrx Effect such as `EntityEffects.persist$`.
+ */
+declare class EntityDispatcherBase<T> implements EntityDispatcher<T> {
+    /** Name of the entity type for which entities are dispatched */
+    entityName: string;
+    /** Creates an {EntityAction} */
+    entityActionFactory: EntityActionFactory;
+    /** The store, scoped to the EntityCache */
+    store: Store<EntityCache>;
+    /** Returns the primary key (id) of this entity */
+    selectId: IdSelector<T>;
+    /**
+     * Dispatcher options configure dispatcher behavior such as
+     * whether add is optimistic or pessimistic by default.
+     */
+    private defaultDispatcherOptions;
+    /** Actions scanned by the store after it processed them with reducers. */
+    private reducedActions$;
+    /** Generates correlation ids for query and save methods */
+    private correlationIdGenerator;
+    /** Utility class with methods to validate EntityAction payloads.*/
+    guard: EntityActionGuard<T>;
+    private entityCollection$;
+    /**
+     * Convert an entity (or partial entity) into the `Update<T>` object
+     * `update...` and `upsert...` methods take `Update<T>` args
+     */
+    toUpdate: (entity: Partial<T>) => Update<T>;
+    constructor(
+    /** Name of the entity type for which entities are dispatched */
+    entityName: string, 
+    /** Creates an {EntityAction} */
+    entityActionFactory: EntityActionFactory, 
+    /** The store, scoped to the EntityCache */
+    store: Store<EntityCache>, 
+    /** Returns the primary key (id) of this entity */
+    selectId: IdSelector<T>, 
+    /**
+     * Dispatcher options configure dispatcher behavior such as
+     * whether add is optimistic or pessimistic by default.
+     */
+    defaultDispatcherOptions: EntityDispatcherDefaultOptions, 
+    /** Actions scanned by the store after it processed them with reducers. */
+    reducedActions$: Observable<Action>, 
+    /** Store selector for the EntityCache */
+    entityCacheSelector: EntityCacheSelector, 
+    /** Generates correlation ids for query and save methods */
+    correlationIdGenerator: CorrelationIdGenerator);
+    /**
+     * Create an {EntityAction} for this entity type.
+     * @param entityOp {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the EntityAction
+     */
+    createEntityAction<P = any>(entityOp: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Create an {EntityAction} for this entity type and
+     * dispatch it immediately to the store.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the dispatched EntityAction
+     */
+    createAndDispatch<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Dispatch an Action to the store.
+     * @param action the Action
+     * @returns the dispatched Action
+     */
+    dispatch(action: Action): Action;
+    /**
+     * Dispatch action to save a new entity to remote storage.
+     * @param entity entity to add, which may omit its key if pessimistic and the server creates the key;
+     * must have a key if optimistic save.
+     * @returns A terminating Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    add(entity: T, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to cancel the persistence operation (query or save).
+     * Will cause save observable to error with a PersistenceCancel error.
+     * Caller is responsible for undoing changes in cache from pending optimistic save
+     * @param correlationId The correlation id for the corresponding EntityAction
+     * @param [reason] explains why canceled and by whom.
+     */
+    cancel(correlationId: any, reason?: string, options?: EntityActionOptions): void;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The primary key of the entity to remove
+     * @returns A terminating Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(entity: T, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The entity to delete
+     * @returns A terminating Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(key: number | string, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * merge the queried entities into the cached collection.
+     * @returns A terminating Observable of the queried entities that are in the collection
+     * after server reports success query or the query error.
+     * @see load()
+     */
+    getAll(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entity with this primary key.
+     * If the server returns an entity,
+     * merge it into the cached collection.
+     * @returns A terminating Observable of the collection
+     * after server reports successful query or the query error.
+     */
+    getByKey(key: any, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string,
+     * and merge the results into the cached collection.
+     * @param queryParams the query in a form understood by the server
+     * @returns A terminating Observable of the queried entities
+     * after server reports successful query or the query error.
+     */
+    getWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * completely replace the cached collection with the queried entities.
+     * @returns A terminating Observable of the entities in the collection
+     * after server reports successful query or the query error.
+     * @see getAll
+     */
+    load(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string,
+     * and completely replace the cached collection with the queried entities.
+     * @param queryParams the query in a form understood by the server
+     * @param [options] options that influence load behavior
+     * @returns A terminating Observable of the queried entities
+     * after server reports successful query or the query error.
+     */
+    loadWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to save the updated entity (or partial entity) in remote storage.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     * @param entity update entity, which might be a partial of T but must at least have its key.
+     * @returns A terminating Observable of the updated entity
+     * after server reports successful save or the save error.
+     */
+    update(entity: Partial<T>, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to save a new or existing entity to remote storage.
+     * Only dispatch this action if your server supports upsert.
+     * @param entity entity to add, which may omit its key if pessimistic and the server creates the key;
+     * must have a key if optimistic save.
+     * @returns A terminating Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    upsert(entity: T, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Replace all entities in the cached collection.
+     * Does not save to remote storage.
+     */
+    addAllToCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Add a new entity directly to the cache.
+     * Does not save to remote storage.
+     * Ignored if an entity with the same primary key is already in cache.
+     */
+    addOneToCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Add multiple new entities directly to the cache.
+     * Does not save to remote storage.
+     * Entities with primary keys already in cache are ignored.
+     */
+    addManyToCache(entities: T[], options?: EntityActionOptions): void;
+    /** Clear the cached entity collection */
+    clearCache(options?: EntityActionOptions): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param entity The entity to remove
+     */
+    removeOneFromCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param key The primary key of the entity to remove
+     */
+    removeOneFromCache(key: number | string, options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param entity The entities to remove
+     */
+    removeManyFromCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param keys The primary keys of the entities to remove
+     */
+    removeManyFromCache(keys: (number | string)[], options?: EntityActionOptions): void;
+    /**
+     * Update a cached entity directly.
+     * Does not update that entity in remote storage.
+     * Ignored if an entity with matching primary key is not in cache.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     */
+    updateOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Update multiple cached entities directly.
+     * Does not update these entities in remote storage.
+     * Entities whose primary keys are not in cache are ignored.
+     * Update entities may be partial but must at least have their keys.
+     * such partial entities patch their cached counterparts.
+     */
+    updateManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Add or update a new entity directly to the cache.
+     * Does not save to remote storage.
+     * Upsert entity might be a partial of T but must at least have its key.
+     * Pass the Update<T> structure as the payload
+     */
+    upsertOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Add or update multiple cached entities directly.
+     * Does not save to remote storage.
+     */
+    upsertManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Set the pattern that the collection's filter applies
+     * when using the `filteredEntities` selector.
+     */
+    setFilter(pattern: any): void;
+    /** Set the loaded flag */
+    setLoaded(isLoaded: boolean): void;
+    /** Set the loading flag */
+    setLoading(isLoading: boolean): void;
+    /** Get key from entity (unless arg is already a key) */
+    private getKey;
+    /**
+     * Return Observable of data from the server-success EntityAction with
+     * the given Correlation Id, after that action was processed by the ngrx store.
+     * or else put the server error on the Observable error channel.
+     * @param crid The correlationId for both the save and response actions.
+     */
+    private getResponseData$;
+    private setQueryEntityActionOptions;
+    private setSaveEntityActionOptions;
+}
+
+/** Creates EntityDispatchers for entity collections */
+declare class EntityDispatcherFactory implements OnDestroy {
+    private entityActionFactory;
+    private store;
+    private entityDispatcherDefaultOptions;
+    private entityCacheSelector;
+    private correlationIdGenerator;
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent action reduced by the store.
+     */
+    reducedActions$: Observable<Action>;
+    private raSubscription;
+    constructor(entityActionFactory: EntityActionFactory, store: Store<EntityCache>, entityDispatcherDefaultOptions: EntityDispatcherDefaultOptions, scannedActions$: Observable<Action>, entityCacheSelector: EntityCacheSelector, correlationIdGenerator: CorrelationIdGenerator);
+    /**
+     * Create an `EntityDispatcher` for an entity type `T` and store.
+     */
+    create<T>(
+    /** Name of the entity type */
+    entityName: string, 
+    /**
+     * Function that returns the primary key for an entity `T`.
+     * Usually acquired from `EntityDefinition` metadata.
+     * @param {IdSelector<T>} selectId
+     */
+    selectId?: IdSelector<T>, 
+    /** Defaults for options that influence dispatcher behavior such as whether
+     * `add()` is optimistic or pessimistic;
+     * @param {Partial<EntityDispatcherDefaultOptions>} defaultOptions
+     */
+    defaultOptions?: Partial<EntityDispatcherDefaultOptions>): EntityDispatcher<T>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDispatcherFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityDispatcherFactory>;
+}
+
+declare class EntityCacheEffects {
+    private actions;
+    private dataService;
+    private entityActionFactory;
+    private logger;
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    private scheduler;
+    /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */
+    private responseDelay;
+    constructor(actions: Actions, dataService: EntityCacheDataService, entityActionFactory: EntityActionFactory, logger: Logger, 
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    scheduler: SchedulerLike);
+    /**
+     * Observable of SAVE_ENTITIES_CANCEL actions with non-null correlation ids
+     */
+    saveEntitiesCancel$: Observable<SaveEntitiesCancel>;
+    saveEntities$: Observable<Action>;
+    /**
+     * Perform the requested SaveEntities actions and return a scalar Observable<Action>
+     * that the effect should dispatch to the store after the server responds.
+     * @param action The SaveEntities action
+     */
+    saveEntities(action: SaveEntities): Observable<Action>;
+    /** return handler of error result of saveEntities, returning a scalar observable of error action */
+    private handleSaveEntitiesError$;
+    /** return handler of the ChangeSet result of successful saveEntities() */
+    private handleSaveEntitiesSuccess$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCacheEffects, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCacheEffects>;
+}
+
+declare const persistOps: EntityOp[];
+declare class EntityEffects {
+    private actions;
+    private dataService;
+    private entityActionFactory;
+    private resultHandler;
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    private scheduler;
+    /** Delay for error and skip observables. Must be multiple of 10 for marble testing. */
+    private responseDelay;
+    /**
+     * Observable of non-null cancellation correlation ids from CANCEL_PERSIST actions
+     */
+    cancel$: Observable<any>;
+    persist$: Observable<Action>;
+    constructor(actions: Actions<EntityAction>, dataService: EntityDataService, entityActionFactory: EntityActionFactory, resultHandler: PersistenceResultHandler, 
+    /**
+     * Injecting an optional Scheduler that will be undefined
+     * in normal application usage, but its injected here so that you can mock out
+     * during testing using the RxJS TestScheduler for simulating passages of time.
+     */
+    scheduler: SchedulerLike);
+    /**
+     * Perform the requested persistence operation and return a scalar Observable<Action>
+     * that the effect should dispatch to the store after the server responds.
+     * @param action A persistence operation EntityAction
+     */
+    persist(action: EntityAction): Observable<Action>;
+    private callDataService;
+    /**
+     * Handle error result of persistence operation on an EntityAction,
+     * returning a scalar observable of error action
+     */
+    private handleError$;
+    /**
+     * Because EntityAction.payload.skip is true, skip the persistence step and
+     * return a scalar success action that looks like the operation succeeded.
+     */
+    private handleSkipSuccess$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityEffects, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityEffects>;
+}
+
+declare class EntityCollectionCreator {
+    private entityDefinitionService?;
+    constructor(entityDefinitionService?: EntityDefinitionService);
+    /**
+     * Create the default collection for an entity type.
+     * @param entityName {string} entity type name
+     */
+    create<T = any, S extends EntityCollection<T> = EntityCollection<T>>(entityName: string): S;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionCreator, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionCreator>;
+}
+declare function createEmptyEntityCollection<T>(entityName?: string): EntityCollection<T>;
+
+/**
+ * The selector functions for entity collection members,
+ * Selects from the entity collection to the collection member
+ * Contrast with {EntitySelectors}.
+ */
+interface CollectionSelectors<T> {
+    readonly [selector: string]: any;
+    /** Count of entities in the cached collection. */
+    readonly selectCount: Selector<EntityCollection<T>, number>;
+    /** All entities in the cached collection. */
+    readonly selectEntities: Selector<EntityCollection<T>, T[]>;
+    /** Map of entity keys to entities */
+    readonly selectEntityMap: Selector<EntityCollection<T>, Dictionary<T>>;
+    /** Filter pattern applied by the entity collection's filter function */
+    readonly selectFilter: Selector<EntityCollection<T>, string>;
+    /** Entities in the cached collection that pass the filter function */
+    readonly selectFilteredEntities: Selector<EntityCollection<T>, T[]>;
+    /** Keys of the cached collection, in the collection's native sort order */
+    readonly selectKeys: Selector<EntityCollection<T>, string[] | number[]>;
+    /** True when the collection has been fully loaded. */
+    readonly selectLoaded: Selector<EntityCollection<T>, boolean>;
+    /** True when a multi-entity query command is in progress. */
+    readonly selectLoading: Selector<EntityCollection<T>, boolean>;
+    /** ChangeState (including original values) of entities with unsaved changes */
+    readonly selectChangeState: Selector<EntityCollection<T>, ChangeStateMap<T>>;
+}
+/**
+ * The selector functions for entity collection members,
+ * Selects from store root, through EntityCache, to the entity collection member
+ * Contrast with {CollectionSelectors}.
+ */
+interface EntitySelectors<T> {
+    /** Name of the entity collection for these selectors */
+    readonly entityName: string;
+    readonly [name: string]: MemoizedSelector<EntityCollection<T>, any> | string;
+    /** The cached EntityCollection itself */
+    readonly selectCollection: MemoizedSelector<Object, EntityCollection<T>>;
+    /** Count of entities in the cached collection. */
+    readonly selectCount: MemoizedSelector<Object, number>;
+    /** All entities in the cached collection. */
+    readonly selectEntities: MemoizedSelector<Object, T[]>;
+    /** The EntityCache */
+    readonly selectEntityCache: MemoizedSelector<Object, EntityCache>;
+    /** Map of entity keys to entities */
+    readonly selectEntityMap: MemoizedSelector<Object, Dictionary<T>>;
+    /** Filter pattern applied by the entity collection's filter function */
+    readonly selectFilter: MemoizedSelector<Object, string>;
+    /** Entities in the cached collection that pass the filter function */
+    readonly selectFilteredEntities: MemoizedSelector<Object, T[]>;
+    /** Keys of the cached collection, in the collection's native sort order */
+    readonly selectKeys: MemoizedSelector<Object, string[] | number[]>;
+    /** True when the collection has been fully loaded. */
+    readonly selectLoaded: MemoizedSelector<Object, boolean>;
+    /** True when a multi-entity query command is in progress. */
+    readonly selectLoading: MemoizedSelector<Object, boolean>;
+    /** ChangeState (including original values) of entities with unsaved changes */
+    readonly selectChangeState: MemoizedSelector<Object, ChangeStateMap<T>>;
+}
+/** Creates EntitySelector functions for entity collections. */
+declare class EntitySelectorsFactory {
+    private entityCollectionCreator;
+    private selectEntityCache;
+    constructor(entityCollectionCreator?: EntityCollectionCreator, selectEntityCache?: EntityCacheSelector);
+    /**
+     * Create the NgRx selector from the store root to the named collection,
+     * e.g. from Object to Heroes.
+     * @param entityName the name of the collection
+     */
+    createCollectionSelector<T = any, C extends EntityCollection<T> = EntityCollection<T>>(entityName: string): MemoizedSelector<Object, C, (s1: EntityCache) => C>;
+    /**
+     * Creates entity collection selectors from metadata.
+     * @param metadata - EntityMetadata for the collection.
+     * May be partial but much have `entityName`.
+     */
+    createCollectionSelectors<T, S extends CollectionSelectors<T> = CollectionSelectors<T>>(metadata: EntityMetadata<T>): S;
+    /**
+     * Creates default entity collection selectors for an entity type.
+     * Use the metadata overload for additional collection selectors.
+     * @param entityName - name of the entity type
+     */
+    createCollectionSelectors<T, S extends CollectionSelectors<T> = CollectionSelectors<T>>(entityName: string): S;
+    /**
+     * Creates the store-rooted selectors for an entity collection.
+     * {EntitySelectors$Factory} turns them into selectors$.
+     *
+     * @param metadata - EntityMetadata for the collection.
+     * May be partial but much have `entityName`.
+     *
+     * Based on ngrx/entity/state_selectors.ts
+     * Differs in that these selectors select from the NgRx store root,
+     * through the collection, to the collection members.
+     */
+    create<T, S extends EntitySelectors<T> = EntitySelectors<T>>(metadata: EntityMetadata<T>): S;
+    /**
+     * Creates the default store-rooted selectors for an entity collection.
+     * {EntitySelectors$Factory} turns them into selectors$.
+     * Use the metadata overload for additional collection selectors.
+     *
+     * @param entityName - name of the entity type.
+     *
+     * Based on ngrx/entity/state_selectors.ts
+     * Differs in that these selectors select from the NgRx store root,
+     * through the collection, to the collection members.
+     */
+    create<T, S extends EntitySelectors<T> = EntitySelectors<T>>(entityName: string): S;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectorsFactory, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntitySelectorsFactory>;
+}
+
+/**
+ * The selector observable functions for entity collection members.
+ */
+interface EntitySelectors$<T> {
+    /** Name of the entity collection for these selectors$ */
+    readonly entityName: string;
+    /** Names from custom selectors from additionalCollectionState fits here, 'any' to avoid conflict with entityName */
+    readonly [name: string]: Observable<any> | Store<any> | any;
+    /** Observable of the collection as a whole */
+    readonly collection$: Observable<EntityCollection> | Store<EntityCollection>;
+    /** Observable of count of entities in the cached collection. */
+    readonly count$: Observable<number> | Store<number>;
+    /** Observable of all entities in the cached collection. */
+    readonly entities$: Observable<T[]> | Store<T[]>;
+    /** Observable of actions related to this entity type. */
+    readonly entityActions$: Observable<EntityAction>;
+    /** Observable of the map of entity keys to entities */
+    readonly entityMap$: Observable<Dictionary<T>> | Store<Dictionary<T>>;
+    /** Observable of error actions related to this entity type. */
+    readonly errors$: Observable<EntityAction>;
+    /** Observable of the filter pattern applied by the entity collection's filter function */
+    readonly filter$: Observable<string> | Store<string>;
+    /** Observable of entities in the cached collection that pass the filter function */
+    readonly filteredEntities$: Observable<T[]> | Store<T[]>;
+    /** Observable of the keys of the cached collection, in the collection's native sort order */
+    readonly keys$: Observable<string[] | number[]> | Store<string[] | number[]>;
+    /** Observable true when the collection has been loaded */
+    readonly loaded$: Observable<boolean> | Store<boolean>;
+    /** Observable true when a multi-entity query command is in progress. */
+    readonly loading$: Observable<boolean> | Store<boolean>;
+    /** ChangeState (including original values) of entities with unsaved changes */
+    readonly changeState$: Observable<ChangeStateMap<T>> | Store<ChangeStateMap<T>>;
+}
+/** Creates observable EntitySelectors$ for entity collections. */
+declare class EntitySelectors$Factory {
+    private store;
+    private actions;
+    private selectEntityCache;
+    /** Observable of the EntityCache */
+    entityCache$: Observable<EntityCache>;
+    /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */
+    entityActionErrors$: Observable<EntityAction>;
+    constructor(store: Store<any>, actions: Actions<EntityAction>, selectEntityCache: EntityCacheSelector);
+    /**
+     * Creates an entity collection's selectors$ observables for this factory's store.
+     * `selectors$` are observable selectors of the cached entity collection.
+     * @param entityName - is also the name of the collection.
+     * @param selectors - selector functions for this collection.
+     **/
+    create<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>>(entityName: string, selectors: EntitySelectors<T>): S$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySelectors$Factory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntitySelectors$Factory>;
+}
+
+/**
+ * A facade for managing
+ * a cached collection of T entities in the ngrx store.
+ */
+interface EntityCollectionService<T> extends EntityCommands<T>, EntitySelectors$<T> {
+    /**
+     * Create an {EntityAction} for this entity type.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the EntityAction
+     */
+    createEntityAction(op: EntityOp, payload?: any, options?: EntityActionOptions): EntityAction<T>;
+    /**
+     * Create an {EntityAction} for this entity type and
+     * dispatch it immediately to the store.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the dispatched EntityAction
+     */
+    createAndDispatch<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /** Dispatcher of EntityCommands (EntityActions) */
+    readonly dispatcher: EntityDispatcher<T>;
+    /** Name of the entity type for this collection service */
+    readonly entityName: string;
+    /** All selector functions of the entity collection */
+    readonly selectors: EntitySelectors<T>;
+    /** All selectors$ (observables of the selectors of entity collection properties) */
+    readonly selectors$: EntitySelectors$<T>;
+}
+
+/** Core ingredients of an EntityCollectionService */
+interface EntityCollectionServiceElements<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>> {
+    readonly dispatcher: EntityDispatcher<T>;
+    readonly entityName: string;
+    readonly selectors: EntitySelectors<T>;
+    readonly selectors$: S$;
+}
+/** Creates the core elements of the EntityCollectionService for an entity type. */
+declare class EntityCollectionServiceElementsFactory {
+    private entityDispatcherFactory;
+    private entityDefinitionService;
+    private entitySelectorsFactory;
+    private entitySelectors$Factory;
+    constructor(entityDispatcherFactory: EntityDispatcherFactory, entityDefinitionService: EntityDefinitionService, entitySelectorsFactory: EntitySelectorsFactory, entitySelectors$Factory: EntitySelectors$Factory);
+    /**
+     * Get the ingredients for making an EntityCollectionService for this entity type
+     * @param entityName - name of the entity type
+     */
+    create<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>>(entityName: string): EntityCollectionServiceElements<T, S$>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionServiceElementsFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionServiceElementsFactory>;
+}
+
+/**
+ * Base class for a concrete EntityCollectionService<T>.
+ * Can be instantiated. Cannot be injected. Use EntityCollectionServiceFactory to create.
+ * @param EntityCollectionServiceElements The ingredients for this service
+ * as a source of supporting services for creating an EntityCollectionService<T> instance.
+ */
+declare class EntityCollectionServiceBase<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>> implements EntityCollectionService<T> {
+    /** Name of the entity type of this collection service */
+    readonly entityName: string;
+    /** Dispatcher of EntityCommands (EntityActions) */
+    readonly dispatcher: EntityDispatcher<T>;
+    /** All selectors of entity collection properties */
+    readonly selectors: EntitySelectors<T>;
+    /** All selectors$ (observables of entity collection properties) */
+    readonly selectors$: S$;
+    constructor(
+    /** Name of the entity type of this collection service */
+    entityName: string, 
+    /** Creates the core elements of the EntityCollectionService for this entity type */
+    serviceElementsFactory: EntityCollectionServiceElementsFactory);
+    /**
+     * Create an {EntityAction} for this entity type.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the EntityAction
+     */
+    createEntityAction<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Create an {EntityAction} for this entity type and
+     * dispatch it immediately to the store.
+     * @param op {EntityOp} the entity operation
+     * @param [data] the action data
+     * @param [options] additional options
+     * @returns the dispatched EntityAction
+     */
+    createAndDispatch<P = any>(op: EntityOp, data?: P, options?: EntityActionOptions): EntityAction<P>;
+    /**
+     * Dispatch an action of any type to the ngrx store.
+     * @param action the Action
+     * @returns the dispatched Action
+     */
+    dispatch(action: Action): Action;
+    /** The NgRx Store for the {EntityCache} */
+    get store(): Store<_ngrx_data.EntityCache>;
+    /**
+     * Utility class with methods to validate EntityAction payloads.
+     */
+    guard: EntityActionGuard<T>;
+    /** Returns the primary key (id) of this entity */
+    selectId: IdSelector<T>;
+    /**
+     * Convert an entity (or partial entity) into the `Update<T>` object
+     * `update...` and `upsert...` methods take `Update<T>` args
+     */
+    toUpdate: (entity: Partial<T>) => Update<T>;
+    /**
+     * Dispatch action to save a new entity to remote storage.
+     * @param entity entity to add, which may omit its key if pessimistic and the server creates the key;
+     * must have a key if optimistic save.
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    add(entity: Partial<T>, options: EntityActionOptions & {
+        isOptimistic: false;
+    }): Observable<T>;
+    add(entity: T, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to cancel the persistence operation (query or save) with the given correlationId.
+     * @param correlationId The correlation id for the corresponding EntityAction
+     * @param [reason] explains why canceled and by whom.
+     * @param [options] options such as the tag and mergeStrategy
+     */
+    cancel(correlationId: any, reason?: string, options?: EntityActionOptions): void;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The entity to delete
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(entity: T, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to delete entity from remote storage by key.
+     * @param key The primary key of the entity to remove
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the deleted key
+     * after server reports successful save or the save error.
+     */
+    delete(key: number | string, options?: EntityActionOptions): Observable<number | string>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * merge the queried entities into the cached collection.
+     * @param [options] options that influence merge behavior
+     * @returns Observable of the collection
+     * after server reports successful query or the query error.
+     * @see load()
+     */
+    getAll(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entity with this primary key.
+     * If the server returns an entity,
+     * merge it into the cached collection.
+     * @param key The primary key of the entity to get.
+     * @param [options] options that influence merge behavior
+     * @returns Observable of the queried entity that is in the collection
+     * after server reports success or the query error.
+     */
+    getByKey(key: any, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string,
+     * and merge the results into the cached collection.
+     * @param queryParams the query in a form understood by the server
+     * @param [options] options that influence merge behavior
+     * @returns Observable of the queried entities
+     * after server reports successful query or the query error.
+     */
+    getWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for all entities and
+     * completely replace the cached collection with the queried entities.
+     * @param [options] options that influence load behavior
+     * @returns Observable of the collection
+     * after server reports successful query or the query error.
+     * @see getAll
+     */
+    load(options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to query remote storage for the entities that satisfy a query expressed
+     * with either a query parameter map or an HTTP URL query string,
+     * and completely replace the cached collection with the queried entities.
+     * @param queryParams the query in a form understood by the server
+     * @param [options] options that influence load behavior
+     * @returns Observable of the queried entities
+     * after server reports successful query or the query error.
+     */
+    loadWithQuery(queryParams: QueryParams | string, options?: EntityActionOptions): Observable<T[]>;
+    /**
+     * Dispatch action to save the updated entity (or partial entity) in remote storage.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     * @param entity update entity, which might be a partial of T but must at least have its key.
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the updated entity
+     * after server reports successful save or the save error.
+     */
+    update(entity: Partial<T>, options?: EntityActionOptions): Observable<T>;
+    /**
+     * Dispatch action to save a new or existing entity to remote storage.
+     * Call only if the server supports upsert.
+     * @param entity entity to add or upsert.
+     * It may omit its key if an add, and is pessimistic, and the server creates the key;
+     * must have a key if optimistic save.
+     * @param [options] options that influence save and merge behavior
+     * @returns Observable of the entity
+     * after server reports successful save or the save error.
+     */
+    upsert(entity: T, options?: EntityActionOptions): Observable<T>;
+    /*** Cache-only operations that do not update remote storage ***/
+    /**
+     * Replace all entities in the cached collection.
+     * Does not save to remote storage.
+     * @param entities to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addAllToCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Add a new entity directly to the cache.
+     * Does not save to remote storage.
+     * Ignored if an entity with the same primary key is already in cache.
+     * @param entity to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addOneToCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Add multiple new entities directly to the cache.
+     * Does not save to remote storage.
+     * Entities with primary keys already in cache are ignored.
+     * @param entities to add directly to cache.
+     * @param [options] options such as mergeStrategy
+     */
+    addManyToCache(entities: T[], options?: EntityActionOptions): void;
+    /** Clear the cached entity collection */
+    clearCache(): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param entity The entity to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeOneFromCache(entity: T, options?: EntityActionOptions): void;
+    /**
+     * Remove an entity directly from the cache.
+     * Does not delete that entity from remote storage.
+     * @param key The primary key of the entity to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeOneFromCache(key: number | string, options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param entity The entities to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeManyFromCache(entities: T[], options?: EntityActionOptions): void;
+    /**
+     * Remove multiple entities directly from the cache.
+     * Does not delete these entities from remote storage.
+     * @param keys The primary keys of the entities to remove
+     * @param [options] options such as mergeStrategy
+     */
+    removeManyFromCache(keys: (number | string)[], options?: EntityActionOptions): void;
+    /**
+     * Update a cached entity directly.
+     * Does not update that entity in remote storage.
+     * Ignored if an entity with matching primary key is not in cache.
+     * The update entity may be partial (but must have its key)
+     * in which case it patches the existing entity.
+     * @param entity to update directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    updateOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Update multiple cached entities directly.
+     * Does not update these entities in remote storage.
+     * Entities whose primary keys are not in cache are ignored.
+     * Update entities may be partial but must at least have their keys.
+     * such partial entities patch their cached counterparts.
+     * @param entities to update directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    updateManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Insert or update a cached entity directly.
+     * Does not save to remote storage.
+     * Upsert entity might be a partial of T but must at least have its key.
+     * Pass the Update<T> structure as the payload.
+     * @param entity to upsert directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    upsertOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;
+    /**
+     * Insert or update multiple cached entities directly.
+     * Does not save to remote storage.
+     * Upsert entities might be partial but must at least have their keys.
+     * Pass an array of the Update<T> structure as the payload.
+     * @param entities to upsert directly in cache.
+     * @param [options] options such as mergeStrategy
+     */
+    upsertManyInCache(entities: Partial<T>[], options?: EntityActionOptions): void;
+    /**
+     * Set the pattern that the collection's filter applies
+     * when using the `filteredEntities` selector.
+     */
+    setFilter(pattern: any): void;
+    /** Set the loaded flag */
+    setLoaded(isLoaded: boolean): void;
+    /** Set the loading flag */
+    setLoading(isLoading: boolean): void;
+    /** Observable of the collection as a whole */
+    collection$: Observable<EntityCollection<T>> | Store<EntityCollection<T>>;
+    /** Observable of count of entities in the cached collection. */
+    count$: Observable<number> | Store<number>;
+    /** Observable of all entities in the cached collection. */
+    entities$: Observable<T[]> | Store<T[]>;
+    /** Observable of actions related to this entity type. */
+    entityActions$: Observable<EntityAction>;
+    /** Observable of the map of entity keys to entities */
+    entityMap$: Observable<Dictionary<T>> | Store<Dictionary<T>>;
+    /** Observable of error actions related to this entity type. */
+    errors$: Observable<EntityAction>;
+    /** Observable of the filter pattern applied by the entity collection's filter function */
+    filter$: Observable<any> | Store<any>;
+    /** Observable of entities in the cached collection that pass the filter function */
+    filteredEntities$: Observable<T[]> | Store<T[]>;
+    /** Observable of the keys of the cached collection, in the collection's native sort order */
+    keys$: Observable<string[] | number[]> | Store<string[] | number[]>;
+    /** Observable true when the collection has been loaded */
+    loaded$: Observable<boolean> | Store<boolean>;
+    /** Observable true when a multi-entity query command is in progress. */
+    loading$: Observable<boolean> | Store<boolean>;
+    /** Original entity values for entities with unsaved changes */
+    changeState$: Observable<ChangeStateMap<T>> | Store<ChangeStateMap<T>>;
+}
+
+/**
+ * Creates EntityCollectionService instances for
+ * a cached collection of T entities in the ngrx store.
+ */
+declare class EntityCollectionServiceFactory {
+    /** Creates the core elements of the EntityCollectionService for an entity type. */
+    entityCollectionServiceElementsFactory: EntityCollectionServiceElementsFactory;
+    constructor(
+    /** Creates the core elements of the EntityCollectionService for an entity type. */
+    entityCollectionServiceElementsFactory: EntityCollectionServiceElementsFactory);
+    /**
+     * Create an EntityCollectionService for an entity type
+     * @param entityName - name of the entity type
+     */
+    create<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>>(entityName: string): EntityCollectionService<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionServiceFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionServiceFactory>;
+}
+
+/**
+ * Class-Interface for EntityCache and EntityCollection services.
+ * Serves as an Angular provider token for this service class.
+ * Includes a registry of EntityCollectionServices for all entity types.
+ * Creates a new default EntityCollectionService for any entity type not in the registry.
+ * Optionally register specialized EntityCollectionServices for individual types
+ */
+declare abstract class EntityServices {
+    /** Dispatch any action to the store */
+    abstract dispatch(action: Action): void;
+    /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */
+    abstract readonly entityActionErrors$: Observable<EntityAction>;
+    /** Observable of the entire entity cache */
+    abstract readonly entityCache$: Observable<EntityCache> | Store<EntityCache>;
+    /** Get (or create) the singleton instance of an EntityCollectionService
+     * @param entityName {string} Name of the entity type of the service
+     */
+    abstract getEntityCollectionService<T = any>(entityName: string): EntityCollectionService<T>;
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent Action (not just EntityAction) reduced by the store.
+     */
+    abstract readonly reducedActions$: Observable<Action>;
+    /** Register an EntityCollectionService under its entity type name.
+     * Will replace a pre-existing service for that type.
+     * @param service {EntityCollectionService} The entity service
+     */
+    abstract registerEntityCollectionService<T>(service: EntityCollectionService<T>): void;
+    /** Register entity services for several entity types at once.
+     * Will replace a pre-existing service for that type.
+     * @param entityCollectionServices Array of EntityCollectionServices to register
+     */
+    abstract registerEntityCollectionServices(entityCollectionServices: EntityCollectionService<any>[]): void;
+    /** Register entity services for several entity types at once.
+     * Will replace a pre-existing service for that type.
+     * @param entityCollectionServiceMap Map of service-name to entity-collection-service
+     */
+    abstract registerEntityCollectionServices(entityCollectionServiceMap: EntityCollectionServiceMap): void;
+}
+/**
+ * A map of service or entity names to their corresponding EntityCollectionServices.
+ */
+interface EntityCollectionServiceMap {
+    [entityName: string]: EntityCollectionService<any>;
+}
+
+/** Core ingredients of an EntityServices class */
+declare class EntityServicesElements {
+    /**
+     * Creates EntityCollectionService instances for
+     * a cached collection of T entities in the ngrx store.
+     */
+    readonly entityCollectionServiceFactory: EntityCollectionServiceFactory;
+    /** The ngrx store, scoped to the EntityCache */
+    readonly store: Store<EntityCache>;
+    constructor(
+    /**
+     * Creates EntityCollectionService instances for
+     * a cached collection of T entities in the ngrx store.
+     */
+    entityCollectionServiceFactory: EntityCollectionServiceFactory, 
+    /** Creates EntityDispatchers for entity collections */
+    entityDispatcherFactory: EntityDispatcherFactory, 
+    /** Creates observable EntitySelectors$ for entity collections. */
+    entitySelectors$Factory: EntitySelectors$Factory, 
+    /** The ngrx store, scoped to the EntityCache */
+    store: Store<EntityCache>);
+    /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */
+    readonly entityActionErrors$: Observable<EntityAction>;
+    /** Observable of the entire entity cache */
+    readonly entityCache$: Observable<EntityCache> | Store<EntityCache>;
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent action reduced by the store.
+     */
+    readonly reducedActions$: Observable<Action>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityServicesElements, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityServicesElements>;
+}
+
+/**
+ * Base/default class of a central registry of EntityCollectionServices for all entity types.
+ * Create your own subclass to add app-specific members for an improved developer experience.
+ *
+ * @usageNotes
+ * ```ts
+ * export class EntityServices extends EntityServicesBase {
+ *   constructor(entityServicesElements: EntityServicesElements) {
+ *     super(entityServicesElements);
+ *   }
+ *   // Extend with well-known, app entity collection services
+ *   // Convenience property to return a typed custom entity collection service
+ *   get companyService() {
+ *     return this.getEntityCollectionService<Model.Company>('Company') as CompanyService;
+ *   }
+ *   // Convenience dispatch methods
+ *   clearCompany(companyId: string) {
+ *     this.dispatch(new ClearCompanyAction(companyId));
+ *   }
+ * }
+ * ```
+ */
+declare class EntityServicesBase implements EntityServices {
+    private entityServicesElements;
+    constructor(entityServicesElements: EntityServicesElements);
+    /** Observable of error EntityActions (e.g. QUERY_ALL_ERROR) for all entity types */
+    get entityActionErrors$(): Observable<EntityAction>;
+    /** Observable of the entire entity cache */
+    get entityCache$(): Observable<EntityCache> | Store<EntityCache>;
+    /** Factory to create a default instance of an EntityCollectionService */
+    get entityCollectionServiceFactory(): EntityCollectionServiceFactory;
+    /**
+     * Actions scanned by the store after it processed them with reducers.
+     * A replay observable of the most recent action reduced by the store.
+     */
+    get reducedActions$(): Observable<Action>;
+    /** The ngrx store, scoped to the EntityCache */
+    protected get store(): Store<EntityCache>;
+    /** Dispatch any action to the store */
+    dispatch(action: Action): void;
+    /** Registry of EntityCollectionService instances */
+    private readonly EntityCollectionServices;
+    /**
+     * Create a new default instance of an EntityCollectionService.
+     * Prefer getEntityCollectionService() unless you really want a new default instance.
+     * This one will NOT be registered with EntityServices!
+     * @param entityName {string} Name of the entity type of the service
+     */
+    protected createEntityCollectionService<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>>(entityName: string): EntityCollectionService<T>;
+    /** Get (or create) the singleton instance of an EntityCollectionService
+     * @param entityName {string} Name of the entity type of the service
+     */
+    getEntityCollectionService<T, S$ extends EntitySelectors$<T> = EntitySelectors$<T>>(entityName: string): EntityCollectionService<T>;
+    /** Register an EntityCollectionService under its entity type name.
+     * Will replace a pre-existing service for that type.
+     * @param service {EntityCollectionService} The entity service
+     * @param serviceName {string} optional service name to use instead of the service's entityName
+     */
+    registerEntityCollectionService<T>(service: EntityCollectionService<T>, serviceName?: string): void;
+    /**
+     * Register entity services for several entity types at once.
+     * Will replace a pre-existing service for that type.
+     * @param entityCollectionServices {EntityCollectionServiceMap | EntityCollectionService<any>[]}
+     * EntityCollectionServices to register, either as a map or an array
+     */
+    registerEntityCollectionServices(entityCollectionServices: EntityCollectionServiceMap | EntityCollectionService<any>[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityServicesBase, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityServicesBase>;
+}
+
+declare const ENTITY_CACHE_NAME = "entityCache";
+declare const ENTITY_CACHE_NAME_TOKEN: InjectionToken<string>;
+declare const ENTITY_CACHE_META_REDUCERS: InjectionToken<MetaReducer<any, any>[]>;
+declare const ENTITY_COLLECTION_META_REDUCERS: InjectionToken<MetaReducer<any, any>[]>;
+declare const INITIAL_ENTITY_CACHE_STATE: InjectionToken<EntityCache | (() => EntityCache)>;
+
+/**
+ * Methods for tracking, committing, and reverting/undoing unsaved entity changes.
+ * Used by EntityCollectionReducerMethods which should call tracker methods BEFORE modifying the collection.
+ * See EntityChangeTracker docs.
+ */
+interface EntityChangeTracker<T> {
+    /**
+     * Commit all changes as when the collection has been completely reloaded from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param collection The entity collection
+     */
+    commitAll(collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Commit changes for the given entities as when they have been refreshed from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param entityOrIdList The entities to clear tracking or their ids.
+     * @param collection The entity collection
+     */
+    commitMany(entityOrIdList: (number | string | T)[], collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Commit changes for the given entity as when it have been refreshed from the server.
+     * Harmless when no entity changes to commit.
+     * @param entityOrId The entity to clear tracking or its id.
+     * @param collection The entity collection
+     */
+    commitOne(entityOrId: number | string | T, collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Merge query results into the collection, adjusting the ChangeState per the mergeStrategy.
+     * @param entities Entities returned from querying the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a queried entity when the corresponding entity in the collection has an unsaved change.
+     * If not specified, implementation supplies a default strategy.
+     * @returns The merged EntityCollection.
+     */
+    mergeQueryResults(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge result of saving new entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving new entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * If not specified, implementation supplies a default strategy.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveAdds(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge successful result of deleting entities on the server that have the given primary keys
+     * Clears the entity changeState for those keys unless the MergeStrategy is ignoreChanges.
+     * @param entities keys primary keys of the entities to remove/delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to adjust change tracking when the corresponding entity in the collection has an unsaved change.
+     * If not specified, implementation supplies a default strategy.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveDeletes(keys: (number | string)[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge result of saving upserted entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving upsert entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * If not specified, implementation supplies a default strategy.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpserts(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge result of saving updated entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param updates Entity response data returned from saving updated entities to the server.
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * If not specified, implementation supplies a default strategy.
+     * @param [skipUnchanged] True means skip update if server didn't change it. False by default.
+     * If the update was optimistic and the server didn't make more changes of its own
+     * then the updates are already in the collection and shouldn't make them again.
+     * @param collection The entity collection
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpdates(updates: UpdateResponseData<T>[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy, skipUnchanged?: boolean): EntityCollection<T>;
+    /**
+     * Track multiple entities before adding them to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entities The entities to add. They must all have their ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     * If not specified, implementation supplies a default strategy.
+     */
+    trackAddMany(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before adding it to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entity The entity to add. It must have an id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     * If not specified, implementation supplies a default strategy.
+     */
+    trackAddOne(entity: T, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before removing them with the intention of deleting them on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param keys The primary keys of the entities to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteMany(keys: (number | string)[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before it is removed with the intention of deleting it on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param key The primary key of the entity to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteOne(key: number | string, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before updating them in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param updates The entities to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateMany(updates: Update<T>[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before updating it in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param update The entity to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateOne(update: Update<T>, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before upserting (adding and updating) them to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entities to add or update. They must be complete entities with ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertMany(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before upsert (adding and updating) it to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entity to add or update. It must be a complete entity with its id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertOne(entity: T, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for all collection.
+     * Harmless when there are no entity changes to undo.
+     * @param collection The entity collection
+     */
+    undoAll(collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for the given entities.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrIdList The entities to revert or their ids.
+     * @param collection The entity collection
+     */
+    undoMany(entityOrIdList: (number | string | T)[], collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for the given entity.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrId The entity to revert or its id.
+     * @param collection The entity collection
+     */
+    undoOne(entityOrId: number | string | T, collection: EntityCollection<T>): EntityCollection<T>;
+}
+
+/**
+ * Map of {EntityOp} to reducer method for the operation.
+ * If an operation is missing, caller should return the collection for that reducer.
+ */
+interface EntityCollectionReducerMethodMap<T> {
+    [method: string]: (collection: EntityCollection<T>, action: EntityAction) => EntityCollection<T>;
+}
+/**
+ * Base implementation of reducer methods for an entity collection.
+ */
+declare class EntityCollectionReducerMethods<T> {
+    entityName: string;
+    definition: EntityDefinition<T>;
+    protected adapter: EntityAdapter<T>;
+    protected guard: EntityActionGuard<T>;
+    /** True if this collection tracks unsaved changes */
+    protected isChangeTracking: boolean;
+    /** Extract the primary key (id); default to `id` */
+    selectId: IdSelector<T>;
+    /**
+     * Track changes to entities since the last query or save
+     * Can revert some or all of those changes
+     */
+    entityChangeTracker: EntityChangeTracker<T>;
+    /**
+     * Convert an entity (or partial entity) into the `Update<T>` object
+     * `id`: the primary key and
+     * `changes`: the entity (or partial entity of changes).
+     */
+    protected toUpdate: (entity: Partial<T>) => Update<T>;
+    /**
+     * Dictionary of the {EntityCollectionReducerMethods} for this entity type,
+     * keyed by the {EntityOp}
+     */
+    readonly methods: EntityCollectionReducerMethodMap<T>;
+    constructor(entityName: string, definition: EntityDefinition<T>, entityChangeTracker?: EntityChangeTracker<T>);
+    /** Cancel a persistence operation */
+    protected cancelPersist(collection: EntityCollection<T>): EntityCollection<T>;
+    protected queryAll(collection: EntityCollection<T>): EntityCollection<T>;
+    protected queryAllError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Merges query results per the MergeStrategy
+     * Sets loading flag to false and loaded flag to true.
+     */
+    protected queryAllSuccess(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected queryByKey(collection: EntityCollection<T>, action: EntityAction<number | string>): EntityCollection<T>;
+    protected queryByKeyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    protected queryByKeySuccess(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    protected queryLoad(collection: EntityCollection<T>): EntityCollection<T>;
+    protected queryLoadError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Replaces all entities in the collection
+     * Sets loaded flag to true, loading flag to false,
+     * and clears changeState for the entire collection.
+     */
+    protected queryLoadSuccess(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected queryMany(collection: EntityCollection<T>, action: EntityAction): EntityCollection<T>;
+    protected queryManyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    protected queryManySuccess(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    /**
+     * Save multiple new entities.
+     * If saving pessimistically, delay adding to collection until server acknowledges success.
+     * If saving optimistically; add immediately.
+     * @param collection The collection to which the entities should be added.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be an array of entities.
+     * If saving optimistically, the entities must have their keys.
+     */
+    protected saveAddMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    /**
+     * Attempt to save new entities failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, new entities are not in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the unsaved entities are in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveAddManyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved new entities to the server.
+     * If saved pessimistically, add the entities from the server to the collection.
+     * If saved optimistically, the added entities are already in the collection.
+     * However, the server might have set or modified other fields (e.g, concurrency field),
+     * and may even return additional new entities.
+     * Therefore, upsert the entities in the collection with the returned values (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic add to avoid this risk.
+     * Note: saveAddManySuccess differs from saveAddOneSuccess when optimistic.
+     * saveAddOneSuccess updates (not upserts) with the lone entity from the server.
+     * There is no effect if the entity is not already in cache.
+     * saveAddManySuccess will add an entity if it is not found in cache.
+     */
+    protected saveAddManySuccess(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    /**
+     * Save a new entity.
+     * If saving pessimistically, delay adding to collection until server acknowledges success.
+     * If saving optimistically; add entity immediately.
+     * @param collection The collection to which the entity should be added.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be an entity.
+     * If saving optimistically, the entity must have a key.
+     */
+    protected saveAddOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    /**
+     * Attempt to save a new entity failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, the entity is not in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the unsaved entity is in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveAddOneError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved a new entity to the server.
+     * If saved pessimistically, add the entity from the server to the collection.
+     * If saved optimistically, the added entity is already in the collection.
+     * However, the server might have set or modified other fields (e.g, concurrency field)
+     * Therefore, update the entity in the collection with the returned value (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic add to avoid this risk.
+     */
+    protected saveAddOneSuccess(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    /**
+     * Delete an entity from the server by key and remove it from the collection (if present).
+     * If the entity is an unsaved new entity, remove it from the collection immediately
+     * and skip the server delete request.
+     * An optimistic save removes an existing entity from the collection immediately;
+     * a pessimistic save removes it after the server confirms successful delete.
+     * @param collection Will remove the entity with this key from the collection.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be a primary key or an entity with a key;
+     * this reducer extracts the key from the entity.
+     */
+    protected saveDeleteOne(collection: EntityCollection<T>, action: EntityAction<number | string | T>): EntityCollection<T>;
+    /**
+     * Attempt to delete the entity on the server failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, the entity could still be in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the entity is not in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveDeleteOneError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully deleted entity on the server. The key of the deleted entity is in the action payload data.
+     * If saved pessimistically, if the entity is still in the collection it will be removed.
+     * If saved optimistically, the entity has already been removed from the collection.
+     */
+    protected saveDeleteOneSuccess(collection: EntityCollection<T>, action: EntityAction<number | string>): EntityCollection<T>;
+    /**
+     * Delete multiple entities from the server by key and remove them from the collection (if present).
+     * Removes unsaved new entities from the collection immediately
+     * but the id is still sent to the server for deletion even though the server will not find that entity.
+     * Therefore, the server must be willing to ignore a delete request for an entity it cannot find.
+     * An optimistic save removes existing entities from the collection immediately;
+     * a pessimistic save removes them after the server confirms successful delete.
+     * @param collection Removes entities from this collection.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be an array of primary keys or entities with a key;
+     * this reducer extracts the key from the entity.
+     */
+    protected saveDeleteMany(collection: EntityCollection<T>, action: EntityAction<(number | string | T)[]>): EntityCollection<T>;
+    /**
+     * Attempt to delete the entities on the server failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, the entities could still be in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the entities are not in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveDeleteManyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully deleted entities on the server. The keys of the deleted entities are in the action payload data.
+     * If saved pessimistically, entities that are still in the collection will be removed.
+     * If saved optimistically, the entities have already been removed from the collection.
+     */
+    protected saveDeleteManySuccess(collection: EntityCollection<T>, action: EntityAction<(number | string)[]>): EntityCollection<T>;
+    /**
+     * Save an update to an existing entity.
+     * If saving pessimistically, update the entity in the collection after the server confirms success.
+     * If saving optimistically, update the entity immediately, before the save request.
+     * @param collection The collection to update
+     * @param action The action payload holds options, including if the save is optimistic,
+     * and the data which, must be an {Update<T>}
+     */
+    protected saveUpdateOne(collection: EntityCollection<T>, action: EntityAction<Update<T>>): EntityCollection<T>;
+    /**
+     * Attempt to update the entity on the server failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, the entity in the collection is in the pre-save state
+     * you may not have to compensate for the error.
+     * If saved optimistically, the entity in the collection was updated
+     * and you may need to compensate for the error.
+     */
+    protected saveUpdateOneError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved the updated entity to the server.
+     * If saved pessimistically, update the entity in the collection with data from the server.
+     * If saved optimistically, the entity was already updated in the collection.
+     * However, the server might have set or modified other fields (e.g, concurrency field)
+     * Therefore, update the entity in the collection with the returned value (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic update to avoid this risk.
+     * @param collection The collection to update
+     * @param action The action payload holds options, including if the save is optimistic, and
+     * the update data which, must be an UpdateResponse<T> that corresponds to the Update sent to the server.
+     * You must include an UpdateResponse even if the save was optimistic,
+     * to ensure that the change tracking is properly reset.
+     */
+    protected saveUpdateOneSuccess(collection: EntityCollection<T>, action: EntityAction<UpdateResponseData<T>>): EntityCollection<T>;
+    /**
+     * Save updated entities.
+     * If saving pessimistically, update the entities in the collection after the server confirms success.
+     * If saving optimistically, update the entities immediately, before the save request.
+     * @param collection The collection to update
+     * @param action The action payload holds options, including if the save is optimistic,
+     * and the data which, must be an array of {Update<T>}.
+     */
+    protected saveUpdateMany(collection: EntityCollection<T>, action: EntityAction<Update<T>[]>): EntityCollection<T>;
+    /**
+     * Attempt to update entities on the server failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, the entities in the collection are in the pre-save state
+     * you may not have to compensate for the error.
+     * If saved optimistically, the entities in the collection were updated
+     * and you may need to compensate for the error.
+     */
+    protected saveUpdateManyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved the updated entities to the server.
+     * If saved pessimistically, the entities in the collection will be updated with data from the server.
+     * If saved optimistically, the entities in the collection were already updated.
+     * However, the server might have set or modified other fields (e.g, concurrency field)
+     * Therefore, update the entity in the collection with the returned values (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic update to avoid this risk.
+     * @param collection The collection to update
+     * @param action The action payload holds options, including if the save is optimistic,
+     * and the data which, must be an array of UpdateResponse<T>.
+     * You must include an UpdateResponse for every Update sent to the server,
+     * even if the save was optimistic, to ensure that the change tracking is properly reset.
+     */
+    protected saveUpdateManySuccess(collection: EntityCollection<T>, action: EntityAction<UpdateResponseData<T>[]>): EntityCollection<T>;
+    /**
+     * Save a new or existing entity.
+     * If saving pessimistically, delay adding to collection until server acknowledges success.
+     * If saving optimistically; add immediately.
+     * @param collection The collection to which the entity should be upserted.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be a whole entity.
+     * If saving optimistically, the entity must have its key.
+     */
+    protected saveUpsertOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    /**
+     * Attempt to save new or existing entity failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, new or updated entity is not in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the unsaved entities are in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveUpsertOneError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved new or existing entities to the server.
+     * If saved pessimistically, add the entities from the server to the collection.
+     * If saved optimistically, the added entities are already in the collection.
+     * However, the server might have set or modified other fields (e.g, concurrency field)
+     * Therefore, update the entities in the collection with the returned values (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic add to avoid this risk.
+     */
+    protected saveUpsertOneSuccess(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    /**
+     * Save multiple new or existing entities.
+     * If saving pessimistically, delay adding to collection until server acknowledges success.
+     * If saving optimistically; add immediately.
+     * @param collection The collection to which the entities should be upserted.
+     * @param action The action payload holds options, including whether the save is optimistic,
+     * and the data, which must be an array of whole entities.
+     * If saving optimistically, the entities must have their keys.
+     */
+    protected saveUpsertMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    /**
+     * Attempt to save new or existing entities failed or timed-out.
+     * Action holds the error.
+     * If saved pessimistically, new entities are not in the collection and
+     * you may not have to compensate for the error.
+     * If saved optimistically, the unsaved entities are in the collection and
+     * you may need to compensate for the error.
+     */
+    protected saveUpsertManyError(collection: EntityCollection<T>, action: EntityAction<EntityActionDataServiceError>): EntityCollection<T>;
+    /**
+     * Successfully saved new or existing entities to the server.
+     * If saved pessimistically, add the entities from the server to the collection.
+     * If saved optimistically, the added entities are already in the collection.
+     * However, the server might have set or modified other fields (e.g, concurrency field)
+     * Therefore, update the entities in the collection with the returned values (if any)
+     * Caution: in a race, this update could overwrite unsaved user changes.
+     * Use pessimistic add to avoid this risk.
+     */
+    protected saveUpsertManySuccess(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    /**
+     * Replaces all entities in the collection
+     * Sets loaded flag to true.
+     * Merges query results, preserving unsaved changes
+     */
+    protected addAll(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected addMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected addOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    protected removeMany(collection: EntityCollection<T>, action: EntityAction<number[] | string[]>): EntityCollection<T>;
+    protected removeOne(collection: EntityCollection<T>, action: EntityAction<number | string>): EntityCollection<T>;
+    protected removeAll(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    protected updateMany(collection: EntityCollection<T>, action: EntityAction<Update<T>[]>): EntityCollection<T>;
+    protected updateOne(collection: EntityCollection<T>, action: EntityAction<Update<T>>): EntityCollection<T>;
+    protected upsertMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected upsertOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    protected commitAll(collection: EntityCollection<T>): EntityCollection<T>;
+    protected commitMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected commitOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    protected undoAll(collection: EntityCollection<T>): EntityCollection<T>;
+    protected undoMany(collection: EntityCollection<T>, action: EntityAction<T[]>): EntityCollection<T>;
+    protected undoOne(collection: EntityCollection<T>, action: EntityAction<T>): EntityCollection<T>;
+    /** Dangerous: Completely replace the collection's ChangeState. Use rarely and wisely. */
+    protected setChangeState(collection: EntityCollection<T>, action: EntityAction<ChangeStateMap<T>>): EntityCollection<T>;
+    /**
+     * Dangerous: Completely replace the collection.
+     * Primarily for testing and rehydration from local storage.
+     * Use rarely and wisely.
+     */
+    protected setCollection(collection: EntityCollection<T>, action: EntityAction<EntityCollection<T>>): EntityCollection<T>;
+    protected setFilter(collection: EntityCollection<T>, action: EntityAction<any>): EntityCollection<T>;
+    protected setLoaded(collection: EntityCollection<T>, action: EntityAction<boolean>): EntityCollection<T>;
+    protected setLoading(collection: EntityCollection<T>, action: EntityAction<boolean>): EntityCollection<T>;
+    protected setLoadingFalse(collection: EntityCollection<T>): EntityCollection<T>;
+    protected setLoadingTrue(collection: EntityCollection<T>): EntityCollection<T>;
+    /** Set the collection's loading flag */
+    protected setLoadingFlag(collection: EntityCollection<T>, loading: boolean): EntityCollection<T>;
+    /** Safely extract data from the EntityAction payload */
+    protected extractData<D = any>(action: EntityAction<D>): D;
+    /** Safely extract MergeStrategy from EntityAction. Set to IgnoreChanges if collection itself is not tracked. */
+    protected extractMergeStrategy(action: EntityAction): MergeStrategy;
+    protected isOptimistic(action: EntityAction): boolean;
+}
+/**
+ * Creates {EntityCollectionReducerMethods} for a given entity type.
+ */
+declare class EntityCollectionReducerMethodsFactory {
+    private entityDefinitionService;
+    constructor(entityDefinitionService: EntityDefinitionService);
+    /** Create the  {EntityCollectionReducerMethods} for the named entity type */
+    create<T>(entityName: string): EntityCollectionReducerMethodMap<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionReducerMethodsFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionReducerMethodsFactory>;
+}
+
+type EntityCollectionReducer<T = any> = (collection: EntityCollection<T>, action: EntityAction) => EntityCollection<T>;
+/** Create a default reducer for a specific entity collection */
+declare class EntityCollectionReducerFactory {
+    private methodsFactory;
+    constructor(methodsFactory: EntityCollectionReducerMethodsFactory);
+    /** Create a default reducer for a collection of entities of T */
+    create<T = any>(entityName: string): EntityCollectionReducer<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionReducerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionReducerFactory>;
+}
+
+/** A hash of EntityCollectionReducers */
+interface EntityCollectionReducers {
+    [entity: string]: EntityCollectionReducer<any>;
+}
+/**
+ * Registry of entity types and their previously-constructed reducers.
+ * Can create a new CollectionReducer, which it registers for subsequent use.
+ */
+declare class EntityCollectionReducerRegistry {
+    private entityCollectionReducerFactory;
+    protected entityCollectionReducers: EntityCollectionReducers;
+    private entityCollectionMetaReducer;
+    constructor(entityCollectionReducerFactory: EntityCollectionReducerFactory, entityCollectionMetaReducers?: MetaReducer<EntityCollection, EntityAction>[]);
+    /**
+     * Get the registered EntityCollectionReducer<T> for this entity type or create one and register it.
+     * @param entityName Name of the entity type for this reducer
+     */
+    getOrCreateReducer<T>(entityName: string): EntityCollectionReducer<T>;
+    /**
+     * Register an EntityCollectionReducer for an entity type
+     * @param entityName - the name of the entity type
+     * @param reducer - reducer for that entity type
+     *
+     * Examples:
+     *   registerReducer('Hero', myHeroReducer);
+     *   registerReducer('Villain', myVillainReducer);
+     */
+    registerReducer<T>(entityName: string, reducer: EntityCollectionReducer<T>): EntityCollectionReducer<T>;
+    /**
+     * Register a batch of EntityCollectionReducers.
+     * @param reducers - reducers to merge into existing reducers
+     *
+     * Examples:
+     *   registerReducers({
+     *     Hero: myHeroReducer,
+     *     Villain: myVillainReducer
+     *   });
+     */
+    registerReducers(reducers: EntityCollectionReducers): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCollectionReducerRegistry, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCollectionReducerRegistry>;
+}
+
+/**
+ * Creates the EntityCacheReducer via its create() method
+ */
+declare class EntityCacheReducerFactory {
+    private entityCollectionCreator;
+    private entityCollectionReducerRegistry;
+    private logger;
+    constructor(entityCollectionCreator: EntityCollectionCreator, entityCollectionReducerRegistry: EntityCollectionReducerRegistry, logger: Logger);
+    /**
+     * Create the @ngrx/data entity cache reducer which either responds to entity cache level actions
+     * or (more commonly) delegates to an EntityCollectionReducer based on the action.payload.entityName.
+     */
+    create(): ActionReducer<EntityCache, Action>;
+    /**
+     * Reducer to clear multiple collections at the same time.
+     * @param entityCache the entity cache
+     * @param action a ClearCollections action whose payload is an array of collection names.
+     * If empty array, does nothing. If no array, clears all the collections.
+     */
+    protected clearCollectionsReducer(entityCache: EntityCache, action: ClearCollections): EntityCache;
+    /**
+     * Reducer to load collection in the form of a hash of entity data for multiple collections.
+     * @param entityCache the entity cache
+     * @param action a LoadCollections action whose payload is the QuerySet of entity collections to load
+     */
+    protected loadCollectionsReducer(entityCache: EntityCache, action: LoadCollections): EntityCache;
+    /**
+     * Reducer to merge query sets in the form of a hash of entity data for multiple collections.
+     * @param entityCache the entity cache
+     * @param action a MergeQuerySet action with the query set and a MergeStrategy
+     */
+    protected mergeQuerySetReducer(entityCache: EntityCache, action: MergeQuerySet): EntityCache;
+    protected saveEntitiesReducer(entityCache: EntityCache, action: SaveEntities): EntityCache;
+    protected saveEntitiesCancelReducer(entityCache: EntityCache, action: SaveEntitiesCancel): EntityCache;
+    protected saveEntitiesErrorReducer(entityCache: EntityCache, action: SaveEntitiesError): EntityCache;
+    protected saveEntitiesSuccessReducer(entityCache: EntityCache, action: SaveEntitiesSuccess): EntityCache;
+    /** Apply reducer for the action's EntityCollection (if the action targets a collection) */
+    private applyCollectionReducer;
+    /** Ensure loading is false for every collection in entityNames */
+    private clearLoadingFlags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCacheReducerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCacheReducerFactory>;
+}
+
+/**
+ * The default implementation of EntityChangeTracker with
+ * methods for tracking, committing, and reverting/undoing unsaved entity changes.
+ * Used by EntityCollectionReducerMethods which should call tracker methods BEFORE modifying the collection.
+ * See EntityChangeTracker docs.
+ */
+declare class EntityChangeTrackerBase<T> implements EntityChangeTracker<T> {
+    private adapter;
+    private selectId;
+    constructor(adapter: EntityAdapter<T>, selectId: IdSelector<T>);
+    /**
+     * Commit all changes as when the collection has been completely reloaded from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param collection The entity collection
+     */
+    commitAll(collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Commit changes for the given entities as when they have been refreshed from the server.
+     * Harmless when there are no entity changes to commit.
+     * @param entityOrIdList The entities to clear tracking or their ids.
+     * @param collection The entity collection
+     */
+    commitMany(entityOrIdList: (number | string | T)[], collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Commit changes for the given entity as when it have been refreshed from the server.
+     * Harmless when no entity changes to commit.
+     * @param entityOrId The entity to clear tracking or its id.
+     * @param collection The entity collection
+     */
+    commitOne(entityOrId: number | string | T, collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Merge query results into the collection, adjusting the ChangeState per the mergeStrategy.
+     * @param entities Entities returned from querying the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a queried entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.PreserveChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeQueryResults(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge result of saving new entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving new entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveAdds(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge successful result of deleting entities on the server that have the given primary keys
+     * Clears the entity changeState for those keys unless the MergeStrategy is ignoreChanges.
+     * @param entities keys primary keys of the entities to remove/delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to adjust change tracking when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveDeletes(keys: (number | string)[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Merge result of saving updated entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param updateResponseData Entity response data returned from saving updated entities to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @param [skipUnchanged] True means skip update if server didn't change it. False by default.
+     * If the update was optimistic and the server didn't make more changes of its own
+     * then the updates are already in the collection and shouldn't make them again.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpdates(updateResponseData: UpdateResponseData<T>[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy, skipUnchanged?: boolean): EntityCollection<T>;
+    /**
+     * Merge result of saving upserted entities into the collection, adjusting the ChangeState per the mergeStrategy.
+     * The default is MergeStrategy.OverwriteChanges.
+     * @param entities Entities returned from saving upserts to the server.
+     * @param collection The entity collection
+     * @param [mergeStrategy] How to merge a saved entity when the corresponding entity in the collection has an unsaved change.
+     * Defaults to MergeStrategy.OverwriteChanges.
+     * @returns The merged EntityCollection.
+     */
+    mergeSaveUpserts(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     *
+     * @param entities Entities to merge
+     * @param collection Collection into which entities are merged
+     * @param defaultMergeStrategy How to merge when action's MergeStrategy is unspecified
+     * @param [mergeStrategy] The action's MergeStrategy
+     */
+    private mergeServerUpserts;
+    /**
+     * Track multiple entities before adding them to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entities The entities to add. They must all have their ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackAddMany(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before adding it to the collection.
+     * Does NOT add to the collection (the reducer's job).
+     * @param entity The entity to add. It must have an id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     * If not specified, implementation supplies a default strategy.
+     */
+    trackAddOne(entity: T, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before removing them with the intention of deleting them on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param keys The primary keys of the entities to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteMany(keys: (number | string)[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before it is removed with the intention of deleting it on the server.
+     * Does NOT remove from the collection (the reducer's job).
+     * @param key The primary key of the entity to delete.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackDeleteOne(key: number | string, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before updating them in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param updates The entities to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateMany(updates: Update<T>[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before updating it in the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param update The entity to update.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpdateOne(update: Update<T>, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track multiple entities before upserting (adding and updating) them to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entities to add or update. They must be complete entities with ids.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertMany(entities: T[], collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Track an entity before upsert (adding and updating) it to the collection.
+     * Does NOT update the collection (the reducer's job).
+     * @param entities The entity to add or update. It must be a complete entity with its id.
+     * @param collection The entity collection
+     * @param [mergeStrategy] Track by default. Don't track if is MergeStrategy.IgnoreChanges.
+     */
+    trackUpsertOne(entity: T, collection: EntityCollection<T>, mergeStrategy?: MergeStrategy): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for all collection.
+     * Harmless when there are no entity changes to undo.
+     * @param collection The entity collection
+     */
+    undoAll(collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for the given entities.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrIdList The entities to revert or their ids.
+     * @param collection The entity collection
+     */
+    undoMany(entityOrIdList: (number | string | T)[], collection: EntityCollection<T>): EntityCollection<T>;
+    /**
+     * Revert the unsaved changes for the given entity.
+     * Harmless when there are no entity changes to undo.
+     * @param entityOrId The entity to revert or its id.
+     * @param collection The entity collection
+     */
+    undoOne(entityOrId: number | string | T, collection: EntityCollection<T>): EntityCollection<T>;
+}
+
+declare class DefaultLogger implements Logger {
+    error(message?: any, extra?: any): void;
+    log(message?: any, extra?: any): void;
+    warn(message?: any, extra?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLogger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultLogger>;
+}
+
+declare class DefaultPluralizer {
+    pluralNames: EntityPluralNames;
+    constructor(pluralNames: EntityPluralNames[]);
+    /**
+     * Pluralize a singular name using common English language pluralization rules
+     * Examples: "company" -> "companies", "employee" -> "employees", "tax" -> "taxes"
+     */
+    pluralize(name: string): string;
+    /**
+     * Register a mapping of entity type name to the entity name's plural
+     * @param pluralNames {EntityPluralNames} plural names for entity types
+     */
+    registerPluralNames(pluralNames: EntityPluralNames): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultPluralizer, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultPluralizer>;
+}
+
+/**
+  Client-side id-generators
+
+  These GUID utility functions are not used by @ngrx/data itself at this time.
+  They are included as candidates for generating persistable correlation ids if that becomes desirable.
+  They are also safe for generating unique entity ids on the client.
+
+  Note they produce 32-character hexadecimal UUID strings,
+  not the 128-bit representation found in server-side languages and databases.
+
+  These utilities are experimental and may be withdrawn or replaced in future.
+*/
+/** Alias for getUuid(). Compare with getGuidComb(). */
+declare function getGuid(): string;
+/**
+ * Creates a sortable, pseudo-GUID (globally unique identifier)
+ * whose trailing 6 bytes (12 hex digits) are time-based
+ * Start either with the given getTime() value, seedTime,
+ * or get the current time in ms.
+ *
+ * @param seed {number} - optional seed for reproducible time-part
+ */
+declare function getGuidComb(seed?: number): string;
+declare function guidComparer(l: string, r: string): number;
+
+/**
+ * Default function that returns the entity's primary key (pkey).
+ * Assumes that the entity has an `id` pkey property.
+ * Returns `undefined` if no entity or `id`.
+ * Every selectId fn must return `undefined` when it cannot produce a full pkey.
+ */
+declare function defaultSelectId(entity: any): any;
+/**
+ * Flatten first arg if it is an array
+ * Allows fn with ...rest signature to be called with an array instead of spread
+ * Example:
+ * ```
+ * // See entity-action-operators.ts
+ * const persistOps = [EntityOp.QUERY_ALL, EntityOp.ADD, ...];
+ * actions.pipe(ofEntityOp(...persistOps)) // works
+ * actions.pipe(ofEntityOp(persistOps)) // also works
+ * ```
+ * */
+declare function flattenArgs<T>(args?: any[]): T[];
+/**
+ * Return a function that converts an entity (or partial entity) into the `Update<T>`
+ * whose `id` is the primary key and
+ * `changes` is the entity (or partial entity of changes).
+ */
+declare function toUpdateFactory<T>(selectId?: IdSelector<T>): (entity: Partial<T>) => Update<T>;
+
+interface EntityDataModuleConfig {
+    entityMetadata?: EntityMetadataMap;
+    entityCacheMetaReducers?: (MetaReducer<EntityCache> | InjectionToken<MetaReducer<EntityCache>>)[];
+    entityCollectionMetaReducers?: MetaReducer<EntityCollection, EntityAction>[];
+    initialEntityCacheState?: EntityCache | (() => EntityCache);
+    pluralNames?: {
+        [name: string]: string;
+    };
+}
+
+/**
+ * Module without effects or dataservices which means no HTTP calls
+ * This module helpful for internal testing.
+ * Also helpful for apps that handle server access on their own and
+ * therefore opt-out of @ngrx/effects for entities
+ */
+declare class EntityDataModuleWithoutEffects {
+    static forRoot(config: EntityDataModuleConfig): ModuleWithProviders<EntityDataModuleWithoutEffects>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataModuleWithoutEffects, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityDataModuleWithoutEffects, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntityDataModuleWithoutEffects>;
+}
+
+/**
+ * entity-data main module includes effects and HTTP data services
+ * Configure with `forRoot`.
+ * No `forFeature` yet.
+ */
+declare class EntityDataModule {
+    static forRoot(config: EntityDataModuleConfig): ModuleWithProviders<EntityDataModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityDataModule, never, [typeof EntityDataModuleWithoutEffects], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntityDataModule>;
+}
+
+/**
+ * Sets up base entity data providers with entity config.
+ * This function should to be used at the root level.
+ *
+ * @usageNotes
+ *
+ * ### Providing entity data with effects
+ *
+ * When used with `withEffects` feature, the `provideEntityData` function is
+ * an alternative to `EntityDataModule.forRoot`
+ *
+ * ```ts
+ * import { provideStore } from '@ngrx/store';
+ * import { provideEffects } from '@ngrx/effects';
+ * import {
+ *   EntityMetadataMap,
+ *   provideEntityData,
+ *   withEffects,
+ * } from '@ngrx/data';
+ *
+ * const entityMetadata: EntityMetadataMap = {
+ *   Hero: {},
+ *   Villain: {},
+ * };
+ * const pluralNames = { Hero: 'Heroes' };
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(),
+ *     provideEffects(),
+ *     provideEntityData({ entityMetadata, pluralNames }, withEffects()),
+ *   ],
+ * });
+ * ```
+ *
+ * ### Providing entity data without effects
+ *
+ * When used without `withEffects` feature, the `provideEntityData` function is
+ * an alternative to `EntityDataModuleWithoutEffects.forRoot`.
+ *
+ * ```ts
+ * import { provideStore } from '@ngrx/store';
+ * import { EntityMetadataMap, provideEntityData } from '@ngrx/data';
+ *
+ * const entityMetadata: EntityMetadataMap = {
+ *   Musician: {},
+ *   Song: {},
+ * };
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(),
+ *     provideEntityData({ entityMetadata }),
+ *   ],
+ * });
+ * ```
+ *
+ */
+declare function provideEntityData(config: EntityDataModuleConfig, ...features: EntityDataFeature[]): EnvironmentProviders;
+declare enum EntityDataFeatureKind {
+    WithEffects = 0
+}
+interface EntityDataFeature {
+    ɵkind: EntityDataFeatureKind;
+    ɵproviders: Provider[];
+}
+/**
+ * Registers entity data effects and provides HTTP data services.
+ *
+ * @see `provideEntityData`
+ */
+declare function withEffects(): EntityDataFeature;
+
+export { ChangeSetItemFactory, ChangeSetOperation, ChangeType, ClearCollections, CorrelationIdGenerator, DataServiceError, DefaultDataService, DefaultDataServiceConfig, DefaultDataServiceFactory, DefaultHttpUrlGenerator, DefaultLogger, DefaultPersistenceResultHandler, DefaultPluralizer, ENTITY_CACHE_META_REDUCERS, ENTITY_CACHE_NAME, ENTITY_CACHE_NAME_TOKEN, ENTITY_CACHE_SELECTOR_TOKEN, ENTITY_COLLECTION_META_REDUCERS, ENTITY_METADATA_TOKEN, EntityActionFactory, EntityActionGuard, EntityCacheAction, EntityCacheDataService, EntityCacheDispatcher, EntityCacheEffects, EntityCacheReducerFactory, EntityChangeTrackerBase, EntityCollectionCreator, EntityCollectionReducerFactory, EntityCollectionReducerMethods, EntityCollectionReducerMethodsFactory, EntityCollectionReducerRegistry, EntityCollectionServiceBase, EntityCollectionServiceElementsFactory, EntityCollectionServiceFactory, EntityDataModule, EntityDataModuleWithoutEffects, EntityDataService, EntityDefinitionService, EntityDispatcherBase, EntityDispatcherDefaultOptions, EntityDispatcherFactory, EntityEffects, EntityHttpResourceUrls, EntityOp, EntitySelectors$Factory, EntitySelectorsFactory, EntityServices, EntityServicesBase, EntityServicesElements, HttpUrlGenerator, INITIAL_ENTITY_CACHE_STATE, LoadCollections, Logger, MergeQuerySet, MergeStrategy, OP_ERROR, OP_SUCCESS, PLURAL_NAMES_TOKEN, PersistanceCanceled, PersistenceResultHandler, Pluralizer, PropsFilterFnFactory, SaveEntities, SaveEntitiesCancel, SaveEntitiesCanceled, SaveEntitiesError, SaveEntitiesSuccess, SetEntityCache, changeSetItemFactory, createEmptyEntityCollection, createEntityCacheSelector, createEntityDefinition, defaultSelectId, entityCacheSelectorProvider, excludeEmptyChangeSetItems, flattenArgs, getGuid, getGuidComb, guidComparer, makeErrorOp, makeSuccessOp, normalizeRoot, ofEntityOp, ofEntityType, persistOps, provideEntityData, toUpdateFactory, withEffects };
+export type { ChangeSet, ChangeSetAdd, ChangeSetDelete, ChangeSetItem, ChangeSetUpdate, ChangeSetUpsert, ChangeState, ChangeStateMap, CollectionSelectors, EntityAction, EntityActionDataServiceError, EntityActionOptions, EntityActionPayload, EntityCache, EntityCacheCommands, EntityCacheQuerySet, EntityCacheSelector, EntityChangeTracker, EntityCollection, EntityCollectionDataService, EntityCollectionReducer, EntityCollectionReducerMethodMap, EntityCollectionReducers, EntityCollectionService, EntityCollectionServiceElements, EntityCollectionServiceMap, EntityCommands, EntityDataModuleConfig, EntityDefinition, EntityDefinitions, EntityDispatcher, EntityFilterFn, EntityMetadata, EntityMetadataMap, EntityPluralNames, EntitySelectors, EntitySelectors$, EntityServerCommands, HttpMethods, HttpOptions, HttpResourceUrls, QueryParams, RequestData, UpdateResponseData };