@ngrx/entity 11.0.0-rc.0 → 11.1.1

package/fesm2015/ngrx-entity.js

@@ -1,80 +1,25 @@
 import { createSelector } from '@ngrx/store';
 import { isDevMode } from '@angular/core';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/entity_state.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template V
- * @return {?}
- */
 function getInitialEntityState() {
     return {
         ids: [],
         entities: {},
     };
 }
-/**
- * @template V
- * @return {?}
- */
 function createInitialStateFactory() {
-    /**
-     * @param {?=} additionalState
-     * @return {?}
-     */
     function getInitialState(additionalState = {}) {
         return Object.assign(getInitialEntityState(), additionalState);
     }
     return { getInitialState };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/state_selectors.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @return {?}
- */
 function createSelectorsFactory() {
-    /**
-     * @param {?=} selectState
-     * @return {?}
-     */
     function getSelectors(selectState) {
-        /** @type {?} */
-        const selectIds = (/**
-         * @param {?} state
-         * @return {?}
-         */
-        (state) => state.ids);
-        /** @type {?} */
-        const selectEntities = (/**
-         * @param {?} state
-         * @return {?}
-         */
-        (state) => state.entities);
-        /** @type {?} */
-        const selectAll = createSelector(selectIds, selectEntities, (/**
-         * @param {?} ids
-         * @param {?} entities
-         * @return {?}
-         */
-        (ids, entities) => ids.map((/**
-         * @param {?} id
-         * @return {?}
-         */
-        (id) => ((/** @type {?} */ (entities)))[id]))));
-        /** @type {?} */
-        const selectTotal = createSelector(selectIds, (/**
-         * @param {?} ids
-         * @return {?}
-         */
-        (ids) => ids.length));
+        const selectIds = (state) => state.ids;
+        const selectEntities = (state) => state.entities;
+        const selectAll = createSelector(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
+        const selectTotal = createSelector(selectIds, (ids) => ids.length);
         if (!selectState) {
             return {
                 selectIds,
@@ -93,39 +38,18 @@ function createSelectorsFactory() {
     return { getSelectors };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/state_adapter.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {number} */
-const DidMutate = {
-    EntitiesOnly: 0,
-    Both: 1,
-    None: 2,
-};
-DidMutate[DidMutate.EntitiesOnly] = 'EntitiesOnly';
-DidMutate[DidMutate.Both] = 'Both';
-DidMutate[DidMutate.None] = 'None';
-/**
- * @template V, R
- * @param {?} mutator
- * @return {?}
- */
+var DidMutate;
+(function (DidMutate) {
+    DidMutate[DidMutate["EntitiesOnly"] = 0] = "EntitiesOnly";
+    DidMutate[DidMutate["Both"] = 1] = "Both";
+    DidMutate[DidMutate["None"] = 2] = "None";
+})(DidMutate || (DidMutate = {}));
 function createStateOperator(mutator) {
-    return (/**
-     * @template S
-     * @param {?} arg
-     * @param {?} state
-     * @return {?}
-     */
-    function operation(arg, state) {
-        /** @type {?} */
+    return function operation(arg, state) {
         const clonedEntityState = {
             ids: [...state.ids],
             entities: Object.assign({}, state.entities),
         };
-        /** @type {?} */
         const didMutate = mutator(arg, clonedEntityState);
         if (didMutate === DidMutate.Both) {
             return Object.assign({}, state, clonedEntityState);
@@ -134,22 +58,10 @@ function createStateOperator(mutator) {
             return Object.assign(Object.assign({}, state), { entities: clonedEntityState.entities });
         }
         return state;
-    });
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/utils.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?} entity
- * @param {?} selectId
- * @return {?}
- */
 function selectIdValue(entity, selectId) {
-    /** @type {?} */
     const key = selectId(entity);
     if (isDevMode() && key === undefined) {
         console.warn('@ngrx/entity: The entity passed to the `selectId` implementation returned undefined.', 'You should probably provide your own `selectId` implementation.', 'The entity that was passed:', entity, 'The `selectId` implementation:', selectId.toString());
@@ -157,24 +69,8 @@ function selectIdValue(entity, selectId) {
     return key;
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/unsorted_state_adapter.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?} selectId
- * @return {?}
- */
 function createUnsortedStateAdapter(selectId) {
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function addOneMutably(entity, state) {
-        /** @type {?} */
         const key = selectIdValue(entity, selectId);
         if (key in state.entities) {
             return DidMutate.None;
@@ -183,37 +79,20 @@ function createUnsortedStateAdapter(selectId) {
         state.entities[key] = entity;
         return DidMutate.Both;
     }
-    /**
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
     function addManyMutably(entities, state) {
-        /** @type {?} */
         let didMutate = false;
         for (const entity of entities) {
             didMutate = addOneMutably(entity, state) !== DidMutate.None || didMutate;
         }
         return didMutate ? DidMutate.Both : DidMutate.None;
     }
-    /**
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
     function setAllMutably(entities, state) {
         state.ids = [];
         state.entities = {};
         addManyMutably(entities, state);
         return DidMutate.Both;
     }
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function setOneMutably(entity, state) {
-        /** @type {?} */
         const key = selectIdValue(entity, selectId);
         if (key in state.entities) {
             state.entities[key] = entity;
@@ -223,74 +102,31 @@ function createUnsortedStateAdapter(selectId) {
         state.entities[key] = entity;
         return DidMutate.Both;
     }
-    /**
-     * @param {?} key
-     * @param {?} state
-     * @return {?}
-     */
     function removeOneMutably(key, state) {
         return removeManyMutably([key], state);
     }
-    /**
-     * @param {?} keysOrPredicate
-     * @param {?} state
-     * @return {?}
-     */
     function removeManyMutably(keysOrPredicate, state) {
-        /** @type {?} */
         const keys = keysOrPredicate instanceof Array
             ? keysOrPredicate
-            : state.ids.filter((/**
-             * @param {?} key
-             * @return {?}
-             */
-            (key) => keysOrPredicate(state.entities[key])));
-        /** @type {?} */
+            : state.ids.filter((key) => keysOrPredicate(state.entities[key]));
         const didMutate = keys
-            .filter((/**
-         * @param {?} key
-         * @return {?}
-         */
-        (key) => key in state.entities))
-            .map((/**
-         * @param {?} key
-         * @return {?}
-         */
-        (key) => delete state.entities[key])).length > 0;
+            .filter((key) => key in state.entities)
+            .map((key) => delete state.entities[key]).length > 0;
         if (didMutate) {
-            state.ids = state.ids.filter((/**
-             * @param {?} id
-             * @return {?}
-             */
-            (id) => id in state.entities));
+            state.ids = state.ids.filter((id) => id in state.entities);
         }
         return didMutate ? DidMutate.Both : DidMutate.None;
     }
-    /**
-     * @template S
-     * @param {?} state
-     * @return {?}
-     */
     function removeAll(state) {
         return Object.assign({}, state, {
             ids: [],
             entities: {},
         });
     }
-    /**
-     * @param {?} keys
-     * @param {?} update
-     * @param {?} state
-     * @return {?}
-     */
     function takeNewKey(keys, update, state) {
-        /** @type {?} */
         const original = state.entities[update.id];
-        /** @type {?} */
         const updated = Object.assign({}, original, update.changes);
-        /** @type {?} */
         const newKey = selectIdValue(updated, selectId);
-        /** @type {?} */
         const hasNewKey = newKey !== update.id;
         if (hasNewKey) {
             keys[update.id] = newKey;
@@ -299,43 +135,18 @@ function createUnsortedStateAdapter(selectId) {
         state.entities[newKey] = updated;
         return hasNewKey;
     }
-    /**
-     * @param {?} update
-     * @param {?} state
-     * @return {?}
-     */
     function updateOneMutably(update, state) {
         return updateManyMutably([update], state);
     }
-    /**
-     * @param {?} updates
-     * @param {?} state
-     * @return {?}
-     */
     function updateManyMutably(updates, state) {
-        /** @type {?} */
         const newKeys = {};
-        updates = updates.filter((/**
-         * @param {?} update
-         * @return {?}
-         */
-        (update) => update.id in state.entities));
-        /** @type {?} */
+        updates = updates.filter((update) => update.id in state.entities);
         const didMutateEntities = updates.length > 0;
         if (didMutateEntities) {
-            /** @type {?} */
-            const didMutateIds = updates.filter((/**
-             * @param {?} update
-             * @return {?}
-             */
-            (update) => takeNewKey(newKeys, update, state))).length >
+            const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length >
                 0;
             if (didMutateIds) {
-                state.ids = state.ids.map((/**
-                 * @param {?} id
-                 * @return {?}
-                 */
-                (id) => newKeys[id] || id));
+                state.ids = state.ids.map((id) => newKeys[id] || id);
                 return DidMutate.Both;
             }
             else {
@@ -344,72 +155,35 @@ function createUnsortedStateAdapter(selectId) {
         }
         return DidMutate.None;
     }
-    /**
-     * @param {?} map
-     * @param {?} state
-     * @return {?}
-     */
     function mapMutably(map, state) {
-        /** @type {?} */
-        const changes = state.ids.reduce((/**
-         * @param {?} changes
-         * @param {?} id
-         * @return {?}
-         */
-        (changes, id) => {
-            /** @type {?} */
+        const changes = state.ids.reduce((changes, id) => {
             const change = map(state.entities[id]);
             if (change !== state.entities[id]) {
                 changes.push({ id, changes: change });
             }
             return changes;
-        }), []);
-        /** @type {?} */
-        const updates = changes.filter((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ({ id }) => id in state.entities));
+        }, []);
+        const updates = changes.filter(({ id }) => id in state.entities);
         return updateManyMutably(updates, state);
     }
-    /**
-     * @param {?} __0
-     * @param {?} state
-     * @return {?}
-     */
     function mapOneMutably({ map, id }, state) {
-        /** @type {?} */
         const entity = state.entities[id];
         if (!entity) {
             return DidMutate.None;
         }
-        /** @type {?} */
         const updatedEntity = map(entity);
         return updateOneMutably({
             id: id,
             changes: updatedEntity,
         }, state);
     }
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function upsertOneMutably(entity, state) {
         return upsertManyMutably([entity], state);
     }
-    /**
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
     function upsertManyMutably(entities, state) {
-        /** @type {?} */
         const added = [];
-        /** @type {?} */
         const updated = [];
         for (const entity of entities) {
-            /** @type {?} */
             const id = selectIdValue(entity, selectId);
             if (id in state.entities) {
                 updated.push({ id, changes: entity });
@@ -418,9 +192,7 @@ function createUnsortedStateAdapter(selectId) {
                 added.push(entity);
             }
         }
-        /** @type {?} */
         const didMutateByUpdated = updateManyMutably(updated, state);
-        /** @type {?} */
         const didMutateByAdded = addManyMutably(added, state);
         switch (true) {
             case didMutateByAdded === DidMutate.None &&
@@ -450,39 +222,13 @@ function createUnsortedStateAdapter(selectId) {
     };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/sorted_state_adapter.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?} selectId
- * @param {?} sort
- * @return {?}
- */
 function createSortedStateAdapter(selectId, sort) {
     const { removeOne, removeMany, removeAll } = createUnsortedStateAdapter(selectId);
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function addOneMutably(entity, state) {
         return addManyMutably([entity], state);
     }
-    /**
-     * @param {?} newModels
-     * @param {?} state
-     * @return {?}
-     */
     function addManyMutably(newModels, state) {
-        /** @type {?} */
-        const models = newModels.filter((/**
-         * @param {?} model
-         * @return {?}
-         */
-        (model) => !(selectIdValue(model, selectId) in state.entities)));
+        const models = newModels.filter((model) => !(selectIdValue(model, selectId) in state.entities));
         if (models.length === 0) {
             return DidMutate.None;
         }
@@ -491,31 +237,16 @@ function createSortedStateAdapter(selectId, sort) {
             return DidMutate.Both;
         }
     }
-    /**
-     * @param {?} models
-     * @param {?} state
-     * @return {?}
-     */
     function setAllMutably(models, state) {
         state.entities = {};
         state.ids = [];
         addManyMutably(models, state);
         return DidMutate.Both;
     }
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function setOneMutably(entity, state) {
-        /** @type {?} */
         const id = selectIdValue(entity, selectId);
         if (id in state.entities) {
-            state.ids = state.ids.filter((/**
-             * @param {?} val
-             * @return {?}
-             */
-            (val) => val !== id));
+            state.ids = state.ids.filter((val) => val !== id);
             merge([entity], state);
             return DidMutate.Both;
         }
@@ -523,63 +254,31 @@ function createSortedStateAdapter(selectId, sort) {
             return addOneMutably(entity, state);
         }
     }
-    /**
-     * @param {?} update
-     * @param {?} state
-     * @return {?}
-     */
     function updateOneMutably(update, state) {
         return updateManyMutably([update], state);
     }
-    /**
-     * @param {?} models
-     * @param {?} update
-     * @param {?} state
-     * @return {?}
-     */
     function takeUpdatedModel(models, update, state) {
         if (!(update.id in state.entities)) {
             return false;
         }
-        /** @type {?} */
         const original = state.entities[update.id];
-        /** @type {?} */
         const updated = Object.assign({}, original, update.changes);
-        /** @type {?} */
         const newKey = selectIdValue(updated, selectId);
         delete state.entities[update.id];
         models.push(updated);
         return newKey !== update.id;
     }
-    /**
-     * @param {?} updates
-     * @param {?} state
-     * @return {?}
-     */
     function updateManyMutably(updates, state) {
-        /** @type {?} */
         const models = [];
-        /** @type {?} */
-        const didMutateIds = updates.filter((/**
-         * @param {?} update
-         * @return {?}
-         */
-        (update) => takeUpdatedModel(models, update, state)))
+        const didMutateIds = updates.filter((update) => takeUpdatedModel(models, update, state))
             .length > 0;
         if (models.length === 0) {
             return DidMutate.None;
         }
         else {
-            /** @type {?} */
             const originalIds = state.ids;
-            /** @type {?} */
             const updatedIndexes = [];
-            state.ids = state.ids.filter((/**
-             * @param {?} id
-             * @param {?} index
-             * @return {?}
-             */
-            (id, index) => {
+            state.ids = state.ids.filter((id, index) => {
                 if (id in state.entities) {
                     return true;
                 }
@@ -587,14 +286,10 @@ function createSortedStateAdapter(selectId, sort) {
                     updatedIndexes.push(index);
                     return false;
                 }
-            }));
+            });
             merge(models, state);
             if (!didMutateIds &&
-                updatedIndexes.every((/**
-                 * @param {?} i
-                 * @return {?}
-                 */
-                (i) => state.ids[i] === originalIds[i]))) {
+                updatedIndexes.every((i) => state.ids[i] === originalIds[i])) {
                 return DidMutate.EntitiesOnly;
             }
             else {
@@ -602,66 +297,34 @@ function createSortedStateAdapter(selectId, sort) {
             }
         }
     }
-    /**
-     * @param {?} updatesOrMap
-     * @param {?} state
-     * @return {?}
-     */
     function mapMutably(updatesOrMap, state) {
-        /** @type {?} */
-        const updates = state.ids.reduce((/**
-         * @param {?} changes
-         * @param {?} id
-         * @return {?}
-         */
-        (changes, id) => {
-            /** @type {?} */
+        const updates = state.ids.reduce((changes, id) => {
             const change = updatesOrMap(state.entities[id]);
             if (change !== state.entities[id]) {
                 changes.push({ id, changes: change });
             }
             return changes;
-        }), []);
+        }, []);
         return updateManyMutably(updates, state);
     }
-    /**
-     * @param {?} __0
-     * @param {?} state
-     * @return {?}
-     */
     function mapOneMutably({ map, id }, state) {
-        /** @type {?} */
         const entity = state.entities[id];
         if (!entity) {
             return DidMutate.None;
         }
-        /** @type {?} */
         const updatedEntity = map(entity);
         return updateOneMutably({
             id: id,
             changes: updatedEntity,
         }, state);
     }
-    /**
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
     function upsertOneMutably(entity, state) {
         return upsertManyMutably([entity], state);
     }
-    /**
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
     function upsertManyMutably(entities, state) {
-        /** @type {?} */
         const added = [];
-        /** @type {?} */
         const updated = [];
         for (const entity of entities) {
-            /** @type {?} */
             const id = selectIdValue(entity, selectId);
             if (id in state.entities) {
                 updated.push({ id, changes: entity });
@@ -670,9 +333,7 @@ function createSortedStateAdapter(selectId, sort) {
                 added.push(entity);
             }
         }
-        /** @type {?} */
         const didMutateByUpdated = updateManyMutably(updated, state);
-        /** @type {?} */
         const didMutateByAdded = addManyMutably(added, state);
         switch (true) {
             case didMutateByAdded === DidMutate.None &&
@@ -685,27 +346,15 @@ function createSortedStateAdapter(selectId, sort) {
                 return DidMutate.EntitiesOnly;
         }
     }
-    /**
-     * @param {?} models
-     * @param {?} state
-     * @return {?}
-     */
     function merge(models, state) {
         models.sort(sort);
-        /** @type {?} */
         const ids = [];
-        /** @type {?} */
         let i = 0;
-        /** @type {?} */
         let j = 0;
         while (i < models.length && j < state.ids.length) {
-            /** @type {?} */
             const model = models[i];
-            /** @type {?} */
             const modelId = selectIdValue(model, selectId);
-            /** @type {?} */
             const entityId = state.ids[j];
-            /** @type {?} */
             const entity = state.entities[entityId];
             if (sort(model, entity) <= 0) {
                 ids.push(modelId);
@@ -722,14 +371,9 @@ function createSortedStateAdapter(selectId, sort) {
         else {
             state.ids = ids.concat(state.ids.slice(j));
         }
-        models.forEach((/**
-         * @param {?} model
-         * @param {?} i
-         * @return {?}
-         */
-        (model, i) => {
+        models.forEach((model, i) => {
             state.entities[selectId(model)] = model;
-        }));
+        });
     }
     return {
         removeOne,
@@ -748,27 +392,10 @@ function createSortedStateAdapter(selectId, sort) {
     };
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/create_adapter.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?=} options
- * @return {?}
- */
 function createEntityAdapter(options = {}) {
-    const { selectId, sortComparer } = Object.assign({ sortComparer: false, selectId: (/**
-         * @param {?} instance
-         * @return {?}
-         */
-        (instance) => instance.id) }, options);
-    /** @type {?} */
+    const { selectId, sortComparer } = Object.assign({ sortComparer: false, selectId: (instance) => instance.id }, options);
     const stateFactory = createInitialStateFactory();
-    /** @type {?} */
     const selectorsFactory = createSelectorsFactory();
-    /** @type {?} */
     const stateAdapter = sortComparer
         ? createSortedStateAdapter(selectId, sortComparer)
         : createUnsortedStateAdapter(selectId);
@@ -776,275 +403,17 @@ function createEntityAdapter(options = {}) {
         sortComparer }, stateFactory), selectorsFactory), stateAdapter);
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/models.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T
- */
-function DictionaryNum() { }
-/**
- * @abstract
- * @template T
- */
 class Dictionary {
 }
-/**
- * @record
- * @template T
- */
-function UpdateStr() { }
-if (false) {
-    /** @type {?} */
-    UpdateStr.prototype.id;
-    /** @type {?} */
-    UpdateStr.prototype.changes;
-}
-/**
- * @record
- * @template T
- */
-function UpdateNum() { }
-if (false) {
-    /** @type {?} */
-    UpdateNum.prototype.id;
-    /** @type {?} */
-    UpdateNum.prototype.changes;
-}
-/**
- * @record
- * @template T
- */
-function EntityMapOneNum() { }
-if (false) {
-    /** @type {?} */
-    EntityMapOneNum.prototype.id;
-    /** @type {?} */
-    EntityMapOneNum.prototype.map;
-}
-/**
- * @record
- * @template T
- */
-function EntityMapOneStr() { }
-if (false) {
-    /** @type {?} */
-    EntityMapOneStr.prototype.id;
-    /** @type {?} */
-    EntityMapOneStr.prototype.map;
-}
-/**
- * @record
- * @template T
- */
-function EntityState() { }
-if (false) {
-    /** @type {?} */
-    EntityState.prototype.ids;
-    /** @type {?} */
-    EntityState.prototype.entities;
-}
-/**
- * @record
- * @template T
- */
-function EntityDefinition() { }
-if (false) {
-    /** @type {?} */
-    EntityDefinition.prototype.selectId;
-    /** @type {?} */
-    EntityDefinition.prototype.sortComparer;
-}
-/**
- * @record
- * @template T
- */
-function EntityStateAdapter() { }
-if (false) {
-    /**
-     * @template S
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.addOne = function (entity, state) { };
-    /**
-     * @template S
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.addMany = function (entities, state) { };
-    /**
-     * @template S
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.setAll = function (entities, state) { };
-    /**
-     * @template S
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.setOne = function (entity, state) { };
-    /**
-     * @template S
-     * @param {?} key
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeOne = function (key, state) { };
-    /**
-     * @template S
-     * @param {?} key
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeOne = function (key, state) { };
-    /**
-     * @template S
-     * @param {?} keys
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeMany = function (keys, state) { };
-    /**
-     * @template S
-     * @param {?} keys
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeMany = function (keys, state) { };
-    /**
-     * @template S
-     * @param {?} predicate
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeMany = function (predicate, state) { };
-    /**
-     * @template S
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.removeAll = function (state) { };
-    /**
-     * @template S
-     * @param {?} update
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.updateOne = function (update, state) { };
-    /**
-     * @template S
-     * @param {?} updates
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.updateMany = function (updates, state) { };
-    /**
-     * @template S
-     * @param {?} entity
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.upsertOne = function (entity, state) { };
-    /**
-     * @template S
-     * @param {?} entities
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.upsertMany = function (entities, state) { };
-    /**
-     * @template S
-     * @param {?} map
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.mapOne = function (map, state) { };
-    /**
-     * @template S
-     * @param {?} map
-     * @param {?} state
-     * @return {?}
-     */
-    EntityStateAdapter.prototype.map = function (map, state) { };
-}
-/**
- * @record
- * @template T, V
- */
-function EntitySelectors() { }
-if (false) {
-    /** @type {?} */
-    EntitySelectors.prototype.selectIds;
-    /** @type {?} */
-    EntitySelectors.prototype.selectEntities;
-    /** @type {?} */
-    EntitySelectors.prototype.selectAll;
-    /** @type {?} */
-    EntitySelectors.prototype.selectTotal;
-}
-/**
- * @record
- * @template T
- */
-function EntityAdapter() { }
-if (false) {
-    /** @type {?} */
-    EntityAdapter.prototype.selectId;
-    /** @type {?} */
-    EntityAdapter.prototype.sortComparer;
-    /**
-     * @return {?}
-     */
-    EntityAdapter.prototype.getInitialState = function () { };
-    /**
-     * @template S
-     * @param {?} state
-     * @return {?}
-     */
-    EntityAdapter.prototype.getInitialState = function (state) { };
-    /**
-     * @return {?}
-     */
-    EntityAdapter.prototype.getSelectors = function () { };
-    /**
-     * @template V
-     * @param {?} selectState
-     * @return {?}
-     */
-    EntityAdapter.prototype.getSelectors = function (selectState) { };
-}
-
-/**
- * @fileoverview added by tsickle
- * Generated from: src/index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 
 /**
- * @fileoverview added by tsickle
- * Generated from: index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * DO NOT EDIT
+ *
+ * This file is automatically generated at build
  */
 
 /**
- * @fileoverview added by tsickle
- * Generated from: ngrx-entity.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 export { Dictionary, createEntityAdapter };