@ngrx/data 20.1.0 → 21.0.0-beta.0

package/src/dispatchers/entity-dispatcher-base.d.ts

@@ -1,269 +0,0 @@
-import { Action, Store } from '@ngrx/store';
-import { IdSelector, Update } from '@ngrx/entity';
-import { Observable } from 'rxjs';
-import { CorrelationIdGenerator } from '../utils/correlation-id-generator';
-import { EntityAction, EntityActionOptions } from '../actions/entity-action';
-import { EntityActionFactory } from '../actions/entity-action-factory';
-import { EntityActionGuard } from '../actions/entity-action-guard';
-import { EntityCache } from '../reducers/entity-cache';
-import { EntityCacheSelector } from '../selectors/entity-cache-selector';
-import { EntityDispatcher } from './entity-dispatcher';
-import { EntityDispatcherDefaultOptions } from './entity-dispatcher-default-options';
-import { EntityOp } from '../actions/entity-op';
-import { QueryParams } from '../dataservices/interfaces';
-/**
- * Dispatches EntityCollection actions to their reducers and effects (default implementation).
- * All save commands rely on an Ngrx Effect such as `EntityEffects.persist$`.
- */
-export 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;
-}

package/src/dispatchers/entity-dispatcher-default-options.d.ts

@@ -1,23 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * 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.
- */
-export 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>;
-}

package/src/dispatchers/entity-dispatcher-factory.d.ts

@@ -1,46 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { Action, Store } from '@ngrx/store';
-import { IdSelector } from '@ngrx/entity';
-import { Observable } from 'rxjs';
-import { CorrelationIdGenerator } from '../utils/correlation-id-generator';
-import { EntityDispatcherDefaultOptions } from './entity-dispatcher-default-options';
-import { EntityActionFactory } from '../actions/entity-action-factory';
-import { EntityCache } from '../reducers/entity-cache';
-import { EntityCacheSelector } from '../selectors/entity-cache-selector';
-import { EntityDispatcher } from './entity-dispatcher';
-import * as i0 from "@angular/core";
-/** Creates EntityDispatchers for entity collections */
-export 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>;
-}

package/src/dispatchers/entity-dispatcher.d.ts

@@ -1,58 +0,0 @@
-import { Action, Store } from '@ngrx/store';
-import { IdSelector, Update } from '@ngrx/entity';
-import { EntityAction, EntityActionOptions } from '../actions/entity-action';
-import { EntityActionGuard } from '../actions/entity-action-guard';
-import { EntityCommands } from './entity-commands';
-import { EntityCache } from '../reducers/entity-cache';
-import { EntityOp } from '../actions/entity-op';
-/**
- * Dispatches EntityCollection actions to their reducers and effects.
- * The substance of the interface is in EntityCommands.
- */
-export 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
- */
-export declare class PersistanceCanceled {
-    readonly message?: string;
-    constructor(message?: string);
-}

package/src/effects/entity-cache-effects.d.ts

@@ -1,46 +0,0 @@
-import { Action } from '@ngrx/store';
-import { Actions } from '@ngrx/effects';
-import { Observable, SchedulerLike } from 'rxjs';
-import { EntityActionFactory } from '../actions/entity-action-factory';
-import { SaveEntities, SaveEntitiesCancel } from '../actions/entity-cache-action';
-import { EntityCacheDataService } from '../dataservices/entity-cache-data.service';
-import { Logger } from '../utils/interfaces';
-import * as i0 from "@angular/core";
-export 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>;
-}

package/src/effects/entity-effects-scheduler.d.ts

@@ -1,4 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { SchedulerLike } from 'rxjs';
-/** Token to inject a special RxJS Scheduler during marble tests. */
-export declare const ENTITY_EFFECTS_SCHEDULER: InjectionToken<SchedulerLike>;

package/src/effects/entity-effects.d.ts

@@ -1,55 +0,0 @@
-import { Action } from '@ngrx/store';
-import { Actions } from '@ngrx/effects';
-import { Observable, SchedulerLike } from 'rxjs';
-import { EntityAction } from '../actions/entity-action';
-import { EntityActionFactory } from '../actions/entity-action-factory';
-import { EntityOp } from '../actions/entity-op';
-import { EntityDataService } from '../dataservices/entity-data.service';
-import { PersistenceResultHandler } from '../dataservices/persistence-result-handler.service';
-import * as i0 from "@angular/core";
-export declare const persistOps: EntityOp[];
-export 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>;
-}

package/src/entity-data-config.d.ts

@@ -1,15 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { MetaReducer } from '@ngrx/store';
-import { EntityCache } from './reducers/entity-cache';
-import { EntityAction } from './actions/entity-action';
-import { EntityMetadataMap } from './entity-metadata/entity-metadata';
-import { EntityCollection } from './reducers/entity-collection';
-export interface EntityDataModuleConfig {
-    entityMetadata?: EntityMetadataMap;
-    entityCacheMetaReducers?: (MetaReducer<EntityCache> | InjectionToken<MetaReducer<EntityCache>>)[];
-    entityCollectionMetaReducers?: MetaReducer<EntityCollection, EntityAction>[];
-    initialEntityCacheState?: EntityCache | (() => EntityCache);
-    pluralNames?: {
-        [name: string]: string;
-    };
-}

package/src/entity-data-without-effects.module.d.ts

@@ -1,15 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { EntityDataModuleConfig } from './entity-data-config';
-import * as i0 from "@angular/core";
-/**
- * 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
- */
-export 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>;
-}

package/src/entity-data.module.d.ts

@@ -1,15 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { EntityDataModuleConfig } from './entity-data-config';
-import * as i0 from "@angular/core";
-import * as i1 from "./entity-data-without-effects.module";
-/**
- * entity-data main module includes effects and HTTP data services
- * Configure with `forRoot`.
- * No `forFeature` yet.
- */
-export declare class EntityDataModule {
-    static forRoot(config: EntityDataModuleConfig): ModuleWithProviders<EntityDataModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<EntityDataModule, never, [typeof i1.EntityDataModuleWithoutEffects], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<EntityDataModule>;
-}

package/src/entity-metadata/entity-definition.d.ts

@@ -1,16 +0,0 @@
-import { EntityAdapter } from '@ngrx/entity';
-import { Comparer, IdSelector } from '@ngrx/entity';
-import { EntityDispatcherDefaultOptions } from '../dispatchers/entity-dispatcher-default-options';
-import { EntityCollection } from '../reducers/entity-collection';
-import { EntityMetadata } from './entity-metadata';
-export 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>;
-}
-export declare function createEntityDefinition<T, S extends object>(metadata: EntityMetadata<T, S>): EntityDefinition<T>;

package/src/entity-metadata/entity-definition.service.d.ts

@@ -1,62 +0,0 @@
-import { EntityDefinition } from './entity-definition';
-import { EntityMetadata, EntityMetadataMap } from './entity-metadata';
-import * as i0 from "@angular/core";
-export interface EntityDefinitions {
-    [entityName: string]: EntityDefinition<any>;
-}
-/** Registry of EntityDefinitions for all cached entity types */
-export 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>;
-}

package/src/entity-metadata/entity-filters.d.ts

@@ -1,12 +0,0 @@
-/**
- * Filters the `entities` array argument and returns the original `entities`,
- * or a new filtered array of entities.
- * NEVER mutate the original `entities` array itself.
- **/
-export 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.
- */
-export declare function PropsFilterFnFactory<T = any>(props?: (keyof T)[]): EntityFilterFn<T>;