@ngrx/data 20.1.0 → 21.0.0-beta.0

package/src/dataservices/entity-data.service.d.ts

@@ -1,48 +0,0 @@
-import { EntityCollectionDataService } from './interfaces';
-import { DefaultDataServiceFactory } from './default-data.service';
-import * as i0 from "@angular/core";
-/**
- * Registry of EntityCollection data services that make REST-like CRUD calls
- * to entity collection endpoints.
- */
-export 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>;
-}

package/src/dataservices/http-url-generator.d.ts

@@ -1,94 +0,0 @@
-import { Pluralizer } from '../utils/interfaces';
-import * as i0 from "@angular/core";
-/**
- * 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`.
- */
-export declare abstract class EntityHttpResourceUrls {
-    [entityName: string]: HttpResourceUrls;
-}
-/**
- * Resource URLS for HTTP operations that target single entity
- * and multi-entity endpoints.
- */
-export 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
- */
-export 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;
-}
-export 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 */
-export declare function normalizeRoot(root: string): string;

package/src/dataservices/interfaces.d.ts

@@ -1,61 +0,0 @@
-import { Observable } from 'rxjs';
-import { Update } from '@ngrx/entity';
-/** A service that performs REST-like HTTP data operations for an entity collection */
-export 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>;
-}
-export type HttpMethods = 'DELETE' | 'GET' | 'POST' | 'PUT';
-export 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.
- */
-export interface QueryParams {
-    [name: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
-}
-/**
- * Options that adhere to the constructor arguments for HttpParams and
- * HttpHeaders.
- */
-export interface HttpOptions {
-    httpParams?: HttpParams;
-    httpHeaders?: HttpHeaders;
-}
-/**
- * Type that adheres to angular's Http Headers
- */
-export type HttpHeaders = string | {
-    [p: string]: string | string[];
-};
-/**
- * Options that partially adheres to angular's HttpParamsOptions. The non-serializable encoder property is omitted.
- */
-export 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>;
-    };
-}

package/src/dataservices/persistence-result-handler.service.d.ts

@@ -1,30 +0,0 @@
-import { Action } from '@ngrx/store';
-import { DataServiceError, EntityActionDataServiceError } from './data-service-error';
-import { EntityAction } from '../actions/entity-action';
-import { EntityActionFactory } from '../actions/entity-action-factory';
-import { Logger } from '../utils/interfaces';
-import * as i0 from "@angular/core";
-/**
- * Handling of responses from persistence operation
- */
-export 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
- */
-export 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>;
-}

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

@@ -1,114 +0,0 @@
-import { Action, Store } from '@ngrx/store';
-import { Observable } from 'rxjs';
-import { CorrelationIdGenerator } from '../utils/correlation-id-generator';
-import { EntityActionOptions } from '../actions/entity-action';
-import { EntityCache } from '../reducers/entity-cache';
-import { EntityDispatcherDefaultOptions } from './entity-dispatcher-default-options';
-import { MergeStrategy } from '../actions/merge-strategy';
-import { ChangeSet, ChangeSetItem } from '../actions/entity-cache-change-set';
-import { EntityCacheQuerySet } from '../actions/entity-cache-action';
-import * as i0 from "@angular/core";
-/**
- * Dispatches Entity Cache actions to the EntityCache reducer
- */
-export 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>;
-}

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

@@ -1,217 +0,0 @@
-import { Observable } from 'rxjs';
-import { EntityActionOptions } from '../actions/entity-action';
-import { QueryParams } from '../dataservices/interfaces';
-/** Commands that update the remote server. */
-export 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 ***/
-export 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 */
-export interface EntityCommands<T> extends EntityServerCommands<T>, EntityCacheCommands<T> {
-}