@ngrx-traits/common 19.2.3 → 20.0.0-beta.2

package/index.d.ts

@@ -1,12 +1,1023 @@
-export * from './load-entities';
-export * from './filter-entities';
-export * from './entities-pagination';
-export * from './select-entities';
-export * from './select-entity';
-export * from './crud-entities';
-export * from './sort-entities';
-export * from './reset';
-export * from './load-entity';
-export * from './async-action';
-export * from './set-entity';
-export * from './entities-sync-to-route-query-params';
+import * as _ngrx_traits_core from '@ngrx-traits/core';
+import { KeyedConfig, PrefixProps, PostfixProps, TraitActions } from '@ngrx-traits/core';
+import { EntityState, Dictionary, IdSelector, Comparer, EntityAdapter, Update, Predicate } from '@ngrx/entity';
+import * as _ngrx_store from '@ngrx/store';
+import { ActionCreator, Action, NotAllowedCheck, ActionCreatorProps } from '@ngrx/store';
+import * as _ngrx_traits_common from '@ngrx-traits/common';
+
+type Status = 'loading' | 'success' | 'fail';
+interface StatusState {
+    status?: Status;
+}
+interface LoadEntitiesState<T> extends EntityState<T>, StatusState {
+}
+type LoadEntitiesActions<T> = {
+    /**
+     * load entities from backend
+     */
+    loadEntities: ActionCreator<string, () => Action<string>>;
+    /**
+     * entities where loaded successfully
+     */
+    loadEntitiesSuccess: ActionCreator<string, (props: {
+        entities: T[];
+        total?: number;
+    }) => {
+        entities: T[];
+        total?: number;
+    } & Action<string>>;
+    /**
+     * entities failed loading
+     */
+    loadEntitiesFail: ActionCreator<string, (props?: {
+        error?: string;
+    }) => {
+        error?: string;
+    } & Action<string>>;
+};
+type LoadEntitiesSelectors<T> = {
+    /**
+     * returns all ids of the entities in an array
+     * @param state
+     */
+    selectEntitiesIdsList: (state: LoadEntitiesState<T>) => string[] | number[];
+    /**
+     * returns all entities in a map with the id as key of the map
+     * @param state
+     */
+    selectEntitiesMap: (state: LoadEntitiesState<T>) => Dictionary<T>;
+    /**
+     * returns all entities in an array
+     * @param state
+     */
+    selectEntitiesList: (state: LoadEntitiesState<T>) => T[];
+    /**
+     * returns the total number of entities
+     * @param state
+     */
+    selectEntitiesTotal: (state: LoadEntitiesState<T>) => number;
+    /**
+     * is currently loading entities
+     * @param state
+     */
+    isEntitiesLoading: (state: LoadEntitiesState<T>) => boolean;
+    /**
+     * were the entities loaded successfully
+     * @param state
+     */
+    isEntitiesLoadingSuccess: (state: LoadEntitiesState<T>) => boolean;
+    /**
+     * did the entities fail loading
+     * @param state
+     */
+    isEntitiesLoadingFail: (state: LoadEntitiesState<T>) => boolean;
+};
+type LoadEntitiesMutators<T> = {
+    /**
+     * set or replace all entities currently in store
+     * @param entities
+     * @param state
+     */
+    setEntitiesList<S extends LoadEntitiesState<T>>(entities: T[], state: S): S;
+};
+type GenericActionCreator = ActionCreator<string, (...args: unknown[]) => Action<string>>;
+declare const loadEntitiesTraitKey = "loadEntities";
+type LoadEntitiesConfig<T = unknown> = {
+    /**
+     * Function that returns the id of an entity if not set it attempts to return the values
+     * of a property call id, this is pass to @ngrx/entity EntityAdapter
+     */
+    selectId?: IdSelector<T>;
+    /**
+     *  Default sort function for to @ngrx/entity EntityAdapter
+     */
+    sortComparer?: false | Comparer<T>;
+    /**
+     *  @ngrx/entity EntityAdapter
+     */
+    adapter: EntityAdapter<T>;
+};
+type LoadEntitiesKeyedConfig<T> = KeyedConfig<typeof loadEntitiesTraitKey, LoadEntitiesConfig<T>>;
+
+/**
+ * Generates the ngrx code needed to load a list of entities from the backend. This trait is the base for all other traits related
+ * to a list of entities, the other will call loadEntities when needing data. See the example for the list of actions and selectors this generates
+ *
+ * @param traitConfig - Config object for the trait factory
+ * @param traitConfig.selectId - Function that returns the id of an entity
+ * @param traitConfig.sortComparer - Default sort function for to @ngrx/entity EntityAdapter
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends LoadEntitiesState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    ids: string[] | number[];
+ * //    entities: Dictionary<Todo>;
+ * //    status?: 'loading' | 'success' | 'fail';
+ *
+ * // generated actions
+ * traits.actions.loadTodos()
+ * traits.actions.loadTodosSuccess({entities: todos})
+ * traits.actions.loadTodosFail();
+ * // generated selectors
+ * traits.selectors.selectTodosList
+ * traits.selectors.selectTodosMap
+ * traits.selectors.selectTodosIds
+ * traits.selectors.selectTodosTotal
+ * traits.selectors.isTodosLoading
+ * traits.selectors.isTodosLoadingSuccess
+ * traits.selectors.isTodosLoadingFail
+ */
+declare function addLoadEntitiesTrait<Entity>(traitConfig?: Omit<LoadEntitiesConfig<Entity>, 'adapter'>): _ngrx_traits_core.TraitFactory<LoadEntitiesState<Entity>, _ngrx_traits_common.LoadEntitiesActions<Entity>, _ngrx_traits_common.LoadEntitiesSelectors<Entity>, _ngrx_traits_common.LoadEntitiesMutators<Entity>, "loadEntities", LoadEntitiesConfig<Entity>, _ngrx_traits_core.AllTraitConfigs>;
+
+interface FilterEntitiesState<F> {
+    filters?: F;
+}
+type FilterPatchConditionalType<F, P> = P extends true ? Partial<F> : F;
+interface FilterActionOverload<F> {
+    <P extends boolean>(props?: {
+        filters: FilterPatchConditionalType<F, P>;
+        forceLoad?: boolean;
+        patch: P;
+    }): {
+        filters: FilterPatchConditionalType<F, P>;
+        forceLoad: boolean;
+        patch: P;
+    } & Action<string>;
+    (props?: {
+        filters: F;
+        forceLoad?: boolean;
+    }): {
+        filters: F;
+        forceLoad: boolean;
+        patch: boolean;
+    } & Action<string>;
+}
+type FilterEntitiesActions<F> = {
+    /**
+     * Store the filters param (read using selectFilter) and fires the loadEntities action
+     * if the filters param has changed, this call is also debounce by default, to disable this
+     * behavior you can use the forceLoad param as true or defaultDebounceTime to 0 in the trait config
+     * to disable permanently.
+     * If the `patch` param is set to true (default is false), the filters are merged with the previous value in the store,
+     * otherwise they are replaced.
+     */
+    filterEntities: ActionCreator<string, FilterActionOverload<F>>;
+};
+type FilterEntitiesSelectors<T, F> = {
+    /**
+     * Returns the stored filters set by the filter action
+     * @param state
+     */
+    selectEntitiesFilter: (state: LoadEntitiesState<T> & FilterEntitiesState<F>) => F | undefined;
+};
+type FilterEntitiesMutators<T, F> = {
+    setEntitiesFilters<S extends LoadEntitiesState<T> & FilterEntitiesState<F>>(filter: F | undefined, state: S): S;
+};
+declare const filterEntitiesTraitKey = "filter";
+type FilterEntitiesConfig<T, F> = {
+    defaultFilter?: F;
+    filterFn?: (filter: F, entity: T) => boolean;
+    defaultDebounceTime?: number;
+    isRemoteFilter?: (previous: F | undefined, current: F | undefined) => boolean;
+};
+type FilterEntitiesKeyedConfig<T, F> = {
+    filter?: FilterEntitiesConfig<T, F>;
+};
+
+/**
+ * Generates the ngrx code needed to filter a list of entities locally or remotely, adds a filter
+ * action and a selectFilter selector, the filter action is debounced and the filter will only
+ * call the loadEntities action if the params have changed, so there is no need to implement that in
+ * the components. The filter action has a `forceLoad` param which can
+ * be use to skip that restriction for one call or setting the `defaultDebounceTime` to 0 for all calls.
+ * Calling the filter action will also replace the `filters` param in the store, if the `patch` param is set
+ * the filters are merged with the previous value in the store.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.defaultFilter - Initial value for the filter
+ * @param traitConfig.filterFn - Function to filter entities in memory, if not present then its expected
+ * is filtered by the backend unless isRemoteFilter is defned
+ * @param traitConfig.defaultDebounceTime - Value in milliseconds. Default to 400ms
+ * @param traitConfig.isRemoteFilter - Function to when it returns true it fires loadEntities so a remote
+ * backend filtering can run, otherwise it uses filterFn to do a local filtering
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends LoadEntitiesState<Todo>, FilterEntitiesState<TodoFilter>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      //addFilterEntitiesTrait<Todo,TodoFilter>() // no params uses remote filtering
+ *      addFilterEntitiesTrait<Todo,TodoFilter>({filterFn: (filter, entity) => // local filtering
+ *          !filter.content || !!entity.content?.includes(filter.content.toLowerCase())
+ *          // or use the following function to switch between remote search and local
+ *          // depending on which properties have changed in the filter
+ *          // isRemoteFilter: (previous, current) => previous?.someRemoteParam !== current?.someRemoteParam,
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    filters?: TodoFilter;
+ *
+ * // generated actions
+ * traits.actions.filterTodos()
+ * // generated selectors
+ * traits.selectors.selectTodosFilter()
+ */
+declare function addFilterEntitiesTrait<Entity, F>({ defaultDebounceTime, defaultFilter, filterFn, isRemoteFilter, }?: FilterEntitiesConfig<Entity, F>): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.FilterEntitiesState<F>, _ngrx_traits_common.FilterEntitiesActions<F>, FilterEntitiesSelectors<Entity, F>, _ngrx_traits_common.FilterEntitiesMutators<Entity, F>, "filter", FilterEntitiesConfig<Entity, F>, _ngrx_traits_core.AllTraitConfigs>;
+
+type CacheType = 'full' | 'partial' | 'grow';
+interface EntitiesPaginationState {
+    pagination: {
+        currentPage: number;
+        requestPage: number;
+        pageSize: number;
+        total?: number;
+        pagesToCache: number;
+        cache: {
+            type: CacheType;
+            start: number;
+            end: number;
+        };
+    };
+}
+type EntitiesPaginationActions = {
+    loadEntitiesPage: ActionCreator<string, (props: {
+        index: number;
+        forceLoad?: boolean;
+    }) => {
+        index: number;
+        forceLoad?: boolean;
+    } & Action<string>>;
+    loadEntitiesPageSuccess: ActionCreator<string, () => Action<string>>;
+    loadEntitiesPageFail: ActionCreator<string, () => Action<string>>;
+    loadEntitiesNextPage: ActionCreator<string, () => Action<string>>;
+    loadEntitiesPreviousPage: ActionCreator<string, () => Action<string>>;
+    loadEntitiesFirstPage: ActionCreator<string, (forceLoad?: boolean) => {
+        forceLoad?: boolean;
+    } & Action<string>>;
+    loadEntitiesLastPage: ActionCreator<string, () => Action<string>>;
+    clearEntitiesPagesCache: ActionCreator<string, () => Action<string>>;
+};
+type EntitiesPaginationSelectors<T> = {
+    selectEntitiesCurrentPageList: (state: LoadEntitiesState<T> & EntitiesPaginationState) => T[];
+    selectEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageModel<T>;
+    selectEntitiesPagedRequest: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PagedRequest;
+    selectEntitiesCurrentPageInfo: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageInfoModel;
+    isLoadingEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => boolean;
+};
+type EntitiesPaginationMutators<Entity> = {
+    mergePaginatedEntities<S extends LoadEntitiesState<Entity> & EntitiesPaginationState>(entities: Entity[], total: number | undefined, state: S): S;
+    setEntitiesPage<Entity, S extends LoadEntitiesState<Entity> & EntitiesPaginationState>(state: S, index: number): S;
+};
+interface PageModel<T> {
+    entities: T[];
+    isLoading: boolean;
+    pageIndex: number;
+    total: number | undefined;
+    pageSize: number;
+    pagesCount: number | undefined;
+    hasPrevious: boolean;
+    hasNext: boolean;
+}
+interface PageInfoModel {
+    pageIndex: number;
+    total: number | undefined;
+    pageSize: number;
+    pagesCount: number | undefined;
+    hasPrevious: boolean;
+    hasNext: boolean;
+    cacheType: CacheType;
+}
+interface PagedRequest {
+    startIndex: number;
+    size: number;
+    page: number;
+}
+declare const entitiesPaginationTraitKey = "pagination";
+interface EntitiesPaginationConfig {
+    cacheType?: CacheType;
+    pageSize?: number;
+    currentPage?: number;
+    pagesToCache?: number;
+}
+interface EntitiesPaginationKeyedConfig {
+    pagination?: EntitiesPaginationConfig;
+}
+
+/**
+ * Generates ngrx code to paginate a list of entities, this has 3 cache `cacheType`
+ * - 'full': The full result is cache in memory and split in pages to render, useful
+ * for small result but not so small that requires been render in pages
+ * - 'partial': Backend returns partial results because is are to big, this has a cache a few pages forward
+ * to avoid calling the backend on each page, the cache is clean when a new loadEntities is required
+ * - 'grow': Similar to partial that the backend returns partial result, but in this case the cache grows,
+ * after each loadEntities the cache is appended to the previous cache, this mode is ideal for infinite scrolls,
+ * where you will only call loadNextPage.
+ * To make the pagination experience smoother the loadEntities action is fired when the current page is equal
+ * to the last cached page, so while the user is reading the page more pages are being loading in the background.
+ * @param config
+ * @param config.cacheType - Default to 'partial', change the cache mode
+ * @param config.pageSize - Default to 10, number of entities on  each page
+ * @param config.currentPage - Default to 0, starting page
+ * @param config.pagesToCache - Default to 3, used in partial and grow cache mode, is the number of
+ * extra pages kept in cache to avoid calling the backend on each page
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,EntitiesPaginationState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addEntitiesPaginationTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    pagination: {
+ * //       currentPage: number;
+ * //       requestPage: number;
+ * //       pageSize: number;
+ * //       total?: number;
+ * //       pagesToCache: number;
+ * //       cache: {
+ * //         type: 'full' | 'partial' | 'grow';
+ * //         start: number;
+ * //         end: number;
+ * //       }
+ * //     }
+ *
+ * // generated actions
+ * traits.actions.loadTodosPage({index})
+ * traits.actions.loadTodosPageSuccess()
+ * traits.actions.loadTodosPageFail()
+ * traits.actions.loadTodosNextPage()
+ * traits.actions.loadTodosPreviousPage()
+ * traits.actions.loadTodosFirstPage()
+ * traits.actions.loadTodosLastPage()
+ * traits.actions.clearTodosPagesCache()
+ * // generated selectors
+ * traits.selectors.selectTodosCurrentPageList()
+ * traits.selectors.isLoadingTodosCurrentPage()
+ * // use isLoadingTodosPage over isLoadingTodos (which will return true even
+ * // if the page loading is not the current one)
+ * traits.selectors.selectTodosCurrentPage()
+ * traits.selectors.selectTodosPagedRequest()// use in effects to get paging parameter
+ * traits.selectors.selectTodosCurrentPageInfo()
+ */
+declare function addEntitiesPaginationTrait<Entity>({ cacheType, pageSize, currentPage, pagesToCache, }?: EntitiesPaginationConfig): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.EntitiesPaginationState, _ngrx_traits_common.EntitiesPaginationActions, EntitiesPaginationSelectors<Entity>, EntitiesPaginationMutators<Entity>, "pagination", EntitiesPaginationConfig, _ngrx_traits_core.AllTraitConfigs>;
+
+interface SelectEntitiesState {
+    selectedIds: Dictionary<boolean>;
+}
+type SelectEntitiesActions = {
+    selectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & Action<string>>;
+    deselectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & Action<string>>;
+    toggleSelectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & Action<string>>;
+    toggleSelectAllEntities: ActionCreator<string, () => Action<string>>;
+    clearEntitiesSelection: ActionCreator<string, () => Action<string>>;
+};
+type SelectEntitiesSelectors<Entity> = {
+    isAllEntitiesSelected: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Selected;
+    selectEntitiesIdsSelectedMap: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Dictionary<boolean>;
+    selectEntitiesIdsSelectedList: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => number[] | string[];
+    selectEntitiesSelectedMap: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Dictionary<Entity>;
+    selectEntitiesSelectedList: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Entity[];
+    selectTotalSelectedEntities: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => number;
+};
+type SelectEntitiesMutators<Entity> = {
+    selectEntities: <S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S) => S;
+    deselectEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S): S;
+    toggleSelectEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S): S;
+    toggleSelectAllEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): S;
+    clearEntitiesSelection<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): S;
+};
+type Selected = 'all' | 'some' | 'none';
+
+/**
+ * Generates ngrx code to add multi selection to a list
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,MultipleSelectionState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntitiesTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    selectedIds: Dictionary<boolean>;
+ *
+ * // generated actions
+ * traits.actions.selectTodos({id})
+ * traits.actions.deselectTodos({id})
+ * traits.actions.toggleSectTodos({id})
+ * traits.actions.toggleSelectAllTodos()
+ * traits.actions.clearTodosSelection()
+ * //generated selectors
+ * traits.selectors.isAllTodosSelected()
+ * traits.selectors.selectTodosIdsSelectedMap()
+ * traits.selectors.selectTodosIdsSelectedList()
+ * traits.selectors.selectTodosSelectedMap()
+ * traits.selectors.selectTodosSelectedList()
+ * traits.selectors.selectTotalSelectedTodos()
+ */
+declare function addSelectEntitiesTrait<Entity>(): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.SelectEntitiesState, SelectEntitiesActions, SelectEntitiesSelectors<Entity>, _ngrx_traits_common.SelectEntitiesMutators<Entity>, "SelectEntities", unknown, _ngrx_traits_core.AllTraitConfigs>;
+
+declare function deselectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+declare function selectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+declare function toggleSelectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+declare function clearEntitiesSelection<S extends SelectEntitiesState>(state: S): S;
+declare function selectTotalSelectedEntities<Entity, S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): number;
+
+interface SelectEntityState {
+    selectedId?: number | string;
+}
+type SelectEntityActions = {
+    selectEntity: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & Action<string>>;
+    deselectEntity: ActionCreator<string, () => Action<string>>;
+    toggleSelectEntity: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & Action<string>>;
+};
+type SelectEntitySelectors<T> = {
+    selectEntityIdSelected: (state: LoadEntitiesState<T> & SelectEntityState) => string | number | undefined;
+    selectEntitySelected: (state: LoadEntitiesState<T> & SelectEntityState) => T | undefined;
+};
+type SelectEntityMutators<T> = {
+    selectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(id: string | number, state: S): S;
+    deselectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(state: S): S;
+    toggleSelectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(id: string | number, state: S): S;
+};
+interface SelectEntityConfig {
+    selectedId?: string | number;
+}
+declare const selectEntityTraitKey = "singleSelection";
+type SelectEntityKeyedConfig = KeyedConfig<typeof selectEntityTraitKey, SelectEntityConfig>;
+
+/**
+ * Generates ngrx code to add single selection to a list
+ * @param config
+ * @param config.selectedId - Default selected id
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,SelectEntityState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntityTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //     selectedId?: number | string;
+ *
+ * // generated actions
+ * traits.actions.selectTodo({id})
+ * traits.actions.deselectTodo()
+ * traits.actions.toggleSelectTodo({id})
+ * //generated selectors
+ * traits.selectors.selectTodoIdSelected()
+ * traits.selectors.selectTodoSelected()
+ */
+declare function addSelectEntityTrait<Entity>(config?: SelectEntityConfig): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.SelectEntityState, SelectEntityActions, _ngrx_traits_common.SelectEntitySelectors<Entity>, _ngrx_traits_common.SelectEntityMutators<unknown>, "singleSelection", SelectEntityConfig, _ngrx_traits_core.AllTraitConfigs>;
+
+declare enum ChangeType {
+    CREATED = "c",
+    UPDATED = "u",
+    DELETED = "d"
+}
+interface Change<T> {
+    id: string | number;
+    changeType: ChangeType;
+    entityChanges?: Partial<T>;
+}
+interface EntityChange<T> {
+    entity: T;
+    changeType: ChangeType;
+}
+interface CrudEntitiesState<T> {
+    changes: Change<T>[];
+}
+type CrudEntitiesActions<T> = {
+    addEntities: ActionCreator<string, (...entities: T[]) => {
+        entities: T[];
+    } & Action<string>>;
+    removeEntities: ActionCreator<string, (...keys: string[] | number[]) => {
+        keys: string[] | number[];
+    } & Action<string>>;
+    updateEntities: ActionCreator<string, (...updates: Update<T>[]) => {
+        updates: Update<T>[];
+    } & Action<string>>;
+    upsertEntities: ActionCreator<string, (...entities: T[]) => {
+        entities: T[];
+    } & Action<string>>;
+    removeAllEntities: ActionCreator<string, (predicate?: Predicate<T>) => {
+        predicate?: Predicate<T>;
+    } & Action<string>>;
+    clearEntitiesChanges: ActionCreator<string, () => Action<string>>;
+};
+type CrudEntitiesSelectors<Entity> = {
+    /**
+     * Return all changes made to the list plus entities, and can be filtered
+     * by change type
+     * @param state
+     * @param props
+     */
+    selectEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>) => EntityChange<Entity>[];
+    /**
+     * Returns the entities plus the kind of change,
+     * filters redundant changes ideal for a batch update
+     * if you add and remove the same and items this changes are remove from the list
+     * if you add and then update one or more times, the updates are discarded
+     * if you update one or more times and then remove, the updates are discarded
+     * @param state
+     */
+    selectFilteredEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>) => EntityChange<Entity>[];
+};
+type CrudEntitiesMutators<Entity> = {
+    addEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(entities: Entity[], state: S): S;
+    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(keys: string[], state: S): S;
+    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(keys: number[], state: S): S;
+    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(predicate: Predicate<Entity>, state: S): S;
+    removeAllEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(state: S): S;
+    clearEntitiesChanges<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(state: S): S;
+    updateEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(updates: Update<Entity>[], state: S): S;
+    upsertEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(entities: Entity[], state: S): S;
+};
+interface CrudEntitiesConfig {
+    storeChanges?: boolean;
+}
+declare const crudEntitiesTraitKey = "crud";
+interface CrudEntitiesKeyedConfig {
+    crud?: CrudEntitiesConfig;
+}
+
+/**
+ * Generates ngrx code to add, remove update, upsert entities on a list, it also
+ * tracks the changes made, helpful for implementing batch updates. The `storeChanges` (false by default),
+ * will store for add and update the changed entity props in the property `entityChanges` of the `Change` object.
+ * @param config
+ * @param config.storeChanges - Will store the changes made, default fals
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>, CrudState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addCrudEntitiesTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    changes: Change<Todo>[];
+ *
+ * // generated actions
+ * traits.actions.addTodos(entity1,entity2...)
+ * traits.actions.updateTodos({id: id1, changes:{prop1}},{id: id2, changes:{prop2}} ...)
+ * traits.actions.upsertTodos(entity1,entity2...)
+ * traits.actions.removeAllTodos()
+ * traits.actions.clearTodosChanges()
+ * // generated selectors
+ * traits.selectors.selectTodosChangesList()
+ * traits.selectors.selectFilteredTodosChangesList()
+ * traits.selectors.selectAllFilteredChanges()
+ */
+declare function addCrudEntitiesTrait<Entity>({ storeChanges, }?: CrudEntitiesConfig): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.CrudEntitiesState<Entity>, CrudEntitiesActions<Entity>, _ngrx_traits_common.CrudEntitiesSelectors<Entity>, _ngrx_traits_common.CrudEntitiesMutators<Entity>, "crud", CrudEntitiesConfig, _ngrx_traits_core.AllTraitConfigs>;
+
+declare type SortDirection = 'asc' | 'desc' | '';
+interface Sort<T> {
+    /** The id of the column being sorted. */
+    active: keyof T;
+    /** The sort direction. */
+    direction: SortDirection;
+}
+interface SortEntitiesState<T> {
+    sort: {
+        current: Sort<T>;
+        default: Sort<T>;
+    };
+}
+type SortEntitiesActions<T> = {
+    sortEntities: ActionCreator<string, (props: Sort<T>) => Sort<T> & Action<string>>;
+    /**
+     * Sets the default sort back
+     */
+    resetEntitiesSort: ActionCreator<string, () => Action<string>>;
+};
+type SortEntitiesSelectors<T> = {
+    selectEntitiesSort: (state: LoadEntitiesState<T> & SortEntitiesState<T>) => Sort<T>;
+};
+type SortEntitiesMutators<T> = {
+    sortEntities<S extends LoadEntitiesState<T> & SortEntitiesState<T>>({ active, direction }: Sort<T>, state: S): S;
+};
+declare const sortTraitKey = "sort";
+interface SortEntitiesConfig<T> {
+    defaultSort: Sort<T>;
+    remote: boolean;
+}
+type SortEntitiesKeyedConfig<T> = KeyedConfig<typeof sortTraitKey, SortEntitiesConfig<T>>;
+
+/**
+ * Generates ngrx code to sort locally or remotely a list of entities
+ * @param config
+ * @param config.defaultSort - Required field, Default entity prop for the sort
+ * @param config.remote - Required field, default to false, when true disables local
+ * sorting and every sort action call will now trigger a loadEntities action and the backend
+ * should sort the data, use selectSort in the effect that call backend to get the requested sort,
+ * when false all sorting is done in memory when the sort action is fired
+ *
+ * @example
+ * // The following trait config
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>, SortState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSortEntitiesTrait<Todo>({
+ *        remote: true,
+ *        defaultSort: {active:'id', direction:'asc'}
+ *      })
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * //   adds following props to the state:
+ * //      sort: {
+ * //        current: Sort<Todo>;
+ * //        default: Sort<Todo>;
+ * //      }
+ *
+ * // generated actions
+ * traits.actions.sortTodos({active:'id', direction:'desc'})
+ * traits.actions.resetTodosSort()
+ * //generated selectors
+ * traits.selectors.selectTodosSort()
+ */
+declare function addSortEntitiesTrait<Entity>({ remote, defaultSort, }: SortEntitiesConfig<Entity>): _ngrx_traits_core.TraitFactory<_ngrx_traits_common.LoadEntitiesState<Entity> & _ngrx_traits_common.SortEntitiesState<Entity>, SortEntitiesActions<Entity>, SortEntitiesSelectors<Entity>, _ngrx_traits_common.SortEntitiesMutators<Entity>, "sort", SortEntitiesConfig<Entity>, _ngrx_traits_core.AllTraitConfigs>;
+
+declare function _isNumberValue(value: any): boolean;
+/**
+ * @internal
+ * @ignore
+ * Gets a sorted copy of the data array based on the state of the Sort.
+ * @param data The array of data that should be sorted.
+ * @param sort The connected MatSort that holds the current sort state.
+ */
+declare function sortData<T>(data: T[], sort: Sort<T>): T[];
+
+/**
+ * Generates the ngrx code needed to reset the current state to the initial state.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.resetOn - set an extra action which will also trigger a reset state,
+ * useful if you want to create an action that reset several features states
+ *
+ * @example
+ * // The following trait config
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addResetEntitiesStateTrait()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // generated actions
+ * traits.actions.resetTodosState()
+ */
+declare function addResetEntitiesStateTrait(traitConfig?: {
+    resetOn?: readonly ActionCreator[];
+}): _ngrx_traits_core.TraitFactory<{}, {
+    resetEntitiesState: ActionCreator<`${string} Reset ${string} State`, () => _ngrx_store.Action<`${string} Reset ${string} State`>>;
+}, {}, {}, "reset", {
+    resetOn?: readonly ActionCreator[];
+}, _ngrx_traits_core.AllTraitConfigs>;
+
+type ActionCreatorWithOptionalProps<T> = T extends undefined ? ActionCreator<string, () => Action<string>> : ActionCreator<string, (props: T & NotAllowedCheck<T & object>) => T & Action<string>>;
+type AsyncActions<Request, Response, Failure> = {
+    '': ActionCreatorWithOptionalProps<Request>;
+    Success: ActionCreatorWithOptionalProps<Response>;
+    Fail: ActionCreatorWithOptionalProps<Failure>;
+};
+type StatusSelectors<S extends StatusState> = {
+    isLoading: (state: S) => boolean;
+    isSuccess: (state: S) => boolean;
+    isFail: (state: S) => boolean;
+};
+type AsyncActionState<J extends string> = PrefixProps<StatusState, J>;
+type AsyncActionSelectors<J extends string, S extends StatusState> = PostfixProps<StatusSelectors<S>, J>;
+type AsyncActionActions<Request, Response, Failure, J extends string> = PrefixProps<AsyncActions<Request, Response, Failure>, J>;
+
+type LoadEntityActions<J extends string, Request extends object, Response extends object, Failure extends object> = PrefixProps<AsyncActionActions<Request, Response, Failure, J>, 'load'> & TraitActions;
+type LoadEntityState<T, J extends string> = AsyncActionState<`load${Capitalize<J & string>}`> & PrefixProps<{
+    ''?: T;
+}, J>;
+type LoadEntitySelectors<T, J extends string> = PostfixProps<{
+    select: (state: LoadEntityState<T, J>) => T;
+}, J>;
+
+type RecordEntity$1<T> = T extends Record<string, infer J> ? J : never;
+/**
+ * Generates ngrx code needed to load and entity and store it in a state. This action can be added
+ * more than once as long as the entityName para is different
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - Optional param for the main request action,
+ * use the props() function for its value, if not present action will have no params,
+ * @param options.actionSuccessProps - Optional param for the request success
+ * action, use the props() function for its value, if not present action success will have no params
+ * @param options.actionFailProps - Optional param for the request fail action,
+ * use the props() function for its value, if not present action fail will have no params
+ * @returns the trait factory
+ *
+ * @example
+ *
+ * export interface TestState
+ * extends LoadEntityState<Client,'client'>{}
+ *
+ * const traits = createEntityFeatureFactory(
+ * ...addLoadEntityTraits({
+ *        entityName: 'client',
+ *        requestProps: props<{ id: string }>(),
+ *        responseProps: props<{ client: Client }>(),
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        LoadEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    loadClientStatus?: 'loading' | 'success' | 'fail';
+ * //    client?: Client;
+ *
+ * // generated actions
+ * traits.actions.loadClient({id:123});
+ * traits.actions.loadClientSuccess({client: {id: '123', name: 'gabs'}});
+ * traits.actions.loadClientFail();
+ * // generated selectors
+ * traits.selectors.selectClient()
+ * traits.selectors.isLoadingLoadClient()
+ * traits.selectors.isSuccessLoadClient()
+ * traits.selectors.isFailLoadClient()
+ */
+declare function addLoadEntityTraits<J extends string, Request extends object | undefined = undefined, Response extends Record<J, any> | undefined = undefined, Failure extends object | undefined = undefined, Entity = RecordEntity$1<Response>, State extends LoadEntityState<any, string> = LoadEntityState<Entity, J>>({ entityName, actionProps, actionSuccessProps, actionFailProps, }: {
+    entityName: J;
+    actionProps?: ActionCreatorProps<Request>;
+    actionSuccessProps?: ActionCreatorProps<Response>;
+    actionFailProps?: ActionCreatorProps<Failure>;
+}): readonly [_ngrx_traits_core.TraitFactory<_ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, `load${Capitalize<J>}`>, _ngrx_traits_core.PrefixProps<{
+    '': _ngrx_traits_common.ActionCreatorWithOptionalProps<Request>;
+    Success: _ngrx_traits_common.ActionCreatorWithOptionalProps<Response>;
+    Fail: _ngrx_traits_common.ActionCreatorWithOptionalProps<Failure>;
+}, `load${Capitalize<J>}`>, _ngrx_traits_core.PostfixProps<{
+    isLoading: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, `load${Capitalize<J>}`>) => boolean;
+    isSuccess: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, `load${Capitalize<J>}`>) => boolean;
+    isFail: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, `load${Capitalize<J>}`>) => boolean;
+}, `load${Capitalize<J>}`>, {}, string, {
+    name: `load${Capitalize<J>}`;
+    actionProps: ActionCreatorProps<Request> | undefined;
+    actionSuccessProps: ActionCreatorProps<Response> | undefined;
+    actionFailProps: ActionCreatorProps<Failure> | undefined;
+}, _ngrx_traits_core.AllTraitConfigs>, _ngrx_traits_core.TraitFactory<State, {}, _ngrx_traits_core.PostfixProps<{
+    select: (state: LoadEntityState<Entity, J>) => Entity;
+}, J>, {}, `load${string}`, {
+    entityName: J;
+    actionProps: ActionCreatorProps<Request> | undefined;
+    actionSuccessProps: ActionCreatorProps<Response> | undefined;
+    actionFailProps: ActionCreatorProps<Failure> | undefined;
+}, _ngrx_traits_core.AllTraitConfigs>];
+
+/**
+ * Generates the typical ngrx code need to make a async action with
+ * a request, success and failure actions, plus a status property to track its progress
+ * and selectors to query the status. This trait can be added more thant once as long
+ * as the name prop is different.
+ *
+ * @param options - Config object for the trait factory
+ * @param options.name - Name of the main request action, should be in camel case
+ * @param options.actionProps - Optional param for the main request action, use the props()
+ * function for its value, if not present action will have no params,
+ * @param options.actionSuccessProps - Optional param for the request success action,
+ * use the props() function for its value, if not present action success will have no params
+ * @param options.actionFailProps - Optional param for the request fail action,
+ * use the props() function for its value, if not present action fail will have no params
+ * @returns the trait factory
+ *
+ * @example
+ *
+ * export interface TestState
+ * extends AsyncActionState<'createClient'>{}
+ *
+ * // The following trait config
+ * const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addAsyncActionTrait({
+ *        name: 'createClient',
+ *        actionProps: props<{ name: string }>(),
+ *        actionSuccessProps: props<{ id: string }>(),
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<AsyncActionState<'createClient'>>(
+ *        'client',
+ *      ),
+ *    });
+ * //   adds following props to the state:
+ * //    createClientStatus?: 'loading' | 'success' | 'fail';
+ *
+ * // generated actions
+ * traits.actions.createClient({name:'Pedro'})
+ * traits.actions.createClientSuccess({id:'123'})
+ * traits.actions.createClientFail();
+ * //generated selectors
+ * traits.selectors.isLoadingCreateClient
+ * traits.selectors.isSuccessCreateClient
+ * traits.selectors.isFailCreateClient
+ */
+declare function addAsyncActionTrait<J extends string, Request extends object | undefined = undefined, Response extends object | undefined = undefined, Failure extends object | undefined = undefined>({ name, actionProps, actionSuccessProps, actionFailProps, }: {
+    name: J;
+    actionProps?: ActionCreatorProps<Request>;
+    actionSuccessProps?: ActionCreatorProps<Response>;
+    actionFailProps?: ActionCreatorProps<Failure>;
+}): _ngrx_traits_core.TraitFactory<_ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, J>, _ngrx_traits_core.PrefixProps<{
+    '': ActionCreatorWithOptionalProps<Request>;
+    Success: ActionCreatorWithOptionalProps<Response>;
+    Fail: ActionCreatorWithOptionalProps<Failure>;
+}, J>, _ngrx_traits_core.PostfixProps<{
+    isLoading: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, J>) => boolean;
+    isSuccess: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, J>) => boolean;
+    isFail: (state: _ngrx_traits_core.PrefixProps<_ngrx_traits_common.StatusState, J>) => boolean;
+}, J>, {}, string, {
+    name: J;
+    actionProps: ActionCreatorProps<Request> | undefined;
+    actionSuccessProps: ActionCreatorProps<Response> | undefined;
+    actionFailProps: ActionCreatorProps<Failure> | undefined;
+}, _ngrx_traits_core.AllTraitConfigs>;
+
+type SetActions<T> = {
+    /**
+     * set entity in the store
+     */
+    set: ActionCreator<string, (props: T) => Action<string>>;
+};
+type SetEntityActions<Entity, J extends string> = PostfixProps<SetActions<Entity>, J>;
+type SetEntityState<Entity, J extends string> = {
+    [key in `${J}`]?: Entity;
+};
+type SetEntitySelectors<Entity, J extends string> = PostfixProps<{
+    select: (state: SetEntityState<Entity, J>) => Entity;
+}, J>;
+
+type RecordEntity<T> = T extends Record<string, infer J> ? J : never;
+/**
+ * Generates ngrx code needed to set and entity in the store state
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - param for the main request action,
+ * use the props() function for its value
+ * @returns the trait factory
+ *
+ * @example
+ *
+ * export interface TestState
+ * extends SetEntityState<Client,'client'>{}
+ *
+ * const traits = createEntityFeatureFactory(
+ * addSetEntityTraits({
+ *        entityName: 'client',
+ *        actionProps: props<{ client: Client }
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        SetEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ * //   adds following props to the state:
+ * //    client?: Client;
+ *
+ * // generated actions
+ * traits.actions.setClient({client: {id:123, name: 'gabs'}});
+ * //generated selectors
+ * traits.selectors.selectClient()
+ */
+declare function addSetEntityTrait<J extends string, Payload extends Record<J, any> | undefined = undefined, Entity = RecordEntity<Payload>, State extends SetEntityState<Entity, J> = SetEntityState<Entity, J>>({ entityName, actionProps, }: {
+    entityName: J;
+    actionProps?: ActionCreatorProps<Payload>;
+}): _ngrx_traits_core.TraitFactory<State, _ngrx_traits_core.PostfixProps<{
+    set: _ngrx_store.ActionCreator<string, (props: Payload) => _ngrx_store.Action<string>>;
+}, J>, _ngrx_traits_core.PostfixProps<{
+    select: (state: SetEntityState<Entity, J>) => Entity;
+}, J>, {}, `load${string}`, {
+    entityName: J;
+    actionProps: ActionCreatorProps<Payload> | undefined;
+}, _ngrx_traits_core.AllTraitConfigs>;
+
+/**
+ * Generates ngrx code necessary to load and set to the current route query params for the filter, sort and paging traits
+ *
+ * @example
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addFilterEntitiesTrait(),
+ *      addSortEntitiesTrait<Todo>({
+ *        remote: true,
+ *        defaultSort: {active:'id', direction:'asc'}
+ *      })
+ *      addEntitiesPaginationTrait<Todo>(),
+ *      addEntitiesSyncToRouteQueryParams()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ *
+ *
+ * // generated actions
+ * traits.actions.loadTodosUsingRouteQueryParams()
+ */
+declare function addEntitiesSyncToRouteQueryParams(): _ngrx_traits_core.TraitFactory<{}, {
+    loadEntitiesUsingRouteQueryParams: ActionCreator<`${string} Load ${string} Using Route Query Params`, () => Action<`${string} Load ${string} Using Route Query Params`>>;
+}, {}, {}, "entitiesSyncToRouteQueryParams", unknown, _ngrx_traits_core.AllTraitConfigs>;
+
+export { ChangeType, _isNumberValue, addAsyncActionTrait, addCrudEntitiesTrait, addEntitiesPaginationTrait, addEntitiesSyncToRouteQueryParams, addFilterEntitiesTrait, addLoadEntitiesTrait, addLoadEntityTraits, addResetEntitiesStateTrait, addSelectEntitiesTrait, addSelectEntityTrait, addSetEntityTrait, addSortEntitiesTrait, clearEntitiesSelection, crudEntitiesTraitKey, deselectEntities, entitiesPaginationTraitKey, filterEntitiesTraitKey, loadEntitiesTraitKey, selectEntities, selectEntityTraitKey, selectTotalSelectedEntities, sortData, sortTraitKey, toggleSelectEntities };
+export type { ActionCreatorWithOptionalProps, AsyncActionActions, AsyncActionSelectors, AsyncActionState, CacheType, Change, CrudEntitiesActions, CrudEntitiesConfig, CrudEntitiesKeyedConfig, CrudEntitiesMutators, CrudEntitiesSelectors, CrudEntitiesState, EntitiesPaginationActions, EntitiesPaginationConfig, EntitiesPaginationKeyedConfig, EntitiesPaginationMutators, EntitiesPaginationSelectors, EntitiesPaginationState, EntityChange, FilterActionOverload, FilterEntitiesActions, FilterEntitiesConfig, FilterEntitiesKeyedConfig, FilterEntitiesMutators, FilterEntitiesSelectors, FilterEntitiesState, GenericActionCreator, LoadEntitiesActions, LoadEntitiesConfig, LoadEntitiesKeyedConfig, LoadEntitiesMutators, LoadEntitiesSelectors, LoadEntitiesState, LoadEntityActions, LoadEntitySelectors, LoadEntityState, PageInfoModel, PageModel, PagedRequest, SelectEntitiesActions, SelectEntitiesMutators, SelectEntitiesSelectors, SelectEntitiesState, SelectEntityActions, SelectEntityConfig, SelectEntityKeyedConfig, SelectEntityMutators, SelectEntitySelectors, SelectEntityState, Selected, SetEntityActions, SetEntitySelectors, SetEntityState, Sort, SortDirection, SortEntitiesActions, SortEntitiesConfig, SortEntitiesKeyedConfig, SortEntitiesMutators, SortEntitiesSelectors, SortEntitiesState, Status, StatusState };