import * as i0 from '@angular/core'; import { ModuleWithProviders, Provider, EnvironmentProviders, Type, InjectionToken, Signal } from '@angular/core'; import { ActionReducer, Store, Action, ActionCreator, MemoizedSelector, Selector } from '@ngrx/store'; import * as rxjs from 'rxjs'; import { Observable, OperatorFunction } from 'rxjs'; import * as _ngrx_effects from '@ngrx/effects'; import { Actions } from '@ngrx/effects'; import * as _briebug_ngrx_auto_entity from '@briebug/ngrx-auto-entity'; interface NgRxAutoEntityModuleConfig { excludeEffects?: boolean; } declare class NgRxAutoEntityRootModuleWithEffects { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare class NgRxAutoEntityRootModuleNoEntityEffects { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare class NgRxAutoEntityRootModuleNoEffects { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare class NgRxAutoEntityFeatureModule { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare class NgrxAutoEntityModule { /** @deprecated use {@link provideAutoEntityStore} */ static forRoot(): ModuleWithProviders; /** @deprecated use {@link provideAutoEntityStore} passing in {@link withoutEntityEffects} */ static forRootNoEntityEffects(): ModuleWithProviders; /** @deprecated use {@link provideAutoEntityStore} passing in {@link withoutEntityEffects} and {@link withoutExtraEffects} */ static forRootNoEffects(): ModuleWithProviders; /** @deprecated use {@link provideAutoEntityState} */ static forFeature(): ModuleWithProviders; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } /** * Provides standard reducer functions to support entity store structure * * @param reducer - The next reducer to be applied */ declare function autoEntityMetaReducer(reducer: ActionReducer): ActionReducer; interface NgRxAutoEntityFeature { ɵkind: FeatureKind; ɵproviders: Provider[]; } declare function getNgRxAutoEntityMetaReducer(): typeof autoEntityMetaReducer; /** * Provides the global Auto-Entity providers. * * @usageNotes * * ### Providing Auto-Entity * * ``` * bootstrapApplication(AppComponent, { * providers: [ * provideStore(appReducer) * provideAutoEntityStore(), * ] * }) * ``` * * @publicApi * @param features A list of Auto-Entity features to include. * @returns A set of providers to set up the Auto-Entity global state. */ declare function provideAutoEntityStore(...features: NgRxAutoEntityFeatures[]): EnvironmentProviders; /** * Provides the feature level Auto-Entity providers. * * @usageNotes * * ### Providing an Auto-Entity Feature State * * ``` * provideState(featureState), * provideAutoEntityState() * ``` * * @publicApi * @returns A set of providers to set up an Auto-Entity feature state. */ declare function provideAutoEntityState(): EnvironmentProviders; /** * Provides an entity's service. * * This will reuse existing services when possible. * * @usageNotes * * ### Providing an Entity's Service * * ``` * provideEntityService(Products, ProductsService) * ``` * * @publicApi * @param modelType The entity model to provide a service for. * @param service The service to provide. * @returns A set of providers to set up an entity's service. */ declare function provideEntityService(modelType: Type, service: Type): EnvironmentProviders; type CustomStoreFeature = NgRxAutoEntityFeature; /** * Customize the provided Auto-Entity Store. * @param storeProvider */ declare function withCustomStore(storeProvider: Type | InjectionToken): CustomStoreFeature; type EntityEffectsFeature = NgRxAutoEntityFeature; /** * Prevent Auto-Entity from registering its entity effects. */ declare function withoutEntityEffects(): EntityEffectsFeature; type ExtraEffectsFeature = NgRxAutoEntityFeature; /** * Prevent Auto-Entity from registering its extra effects. * * This includes all select, deselect, and edit effects. */ declare function withoutExtraEffects(): ExtraEffectsFeature; type NgRxAutoEntityFeatures = CustomStoreFeature | EntityEffectsFeature | ExtraEffectsFeature; declare const enum NgRxAutoEntityFeatureKind { CustomStoreFeature = 0, EntityEffectsFeature = 1, ExtraEffectsFeature = 2 } interface IPage { page: number; size: number; } type Page = IPage; interface IPageInfo { page: Page; totalCount: number; } type RangeValue = string | number | Date; interface IStartEndRange { start: RangeValue; end: RangeValue; } interface IFirstLastRange { first: RangeValue; last: RangeValue; } interface ISkipTakeRange { skip: number; take: number; } type Range = IStartEndRange | IFirstLastRange | ISkipTakeRange; interface IRangeInfo { range: Range; totalCount: number; } type EntityIdentity = string | number; /** * Structure for how entities are stored within the `entities` state property: * a single object with the key being each entity's @Key value and the value being the entity itself */ interface IEntityDictionary { [key: string]: TModel; } /** * Structure for how entity selections are stored */ interface IEntitySelections { currentEntityKey?: EntityIdentity; currentEntitiesKeys?: EntityIdentity[]; } /** * Structure for how entity edits are stored */ interface IEntityEdits { editedEntity?: Partial; isDirty?: boolean; } /** * Structure for how entity paging info is stored */ interface IEntityPaging { currentPage?: Page; currentRange?: Range; totalPageableCount?: number; } /** * Structure for how entity tracking is stored */ interface IEntityTracking { isLoading?: boolean; isSaving?: boolean; isDeleting?: boolean; loadedAt?: number; savedAt?: number; createdAt?: number; updatedAt?: number; replacedAt?: number; deletedAt?: number; } /** * Structure for how entities are stored, including useful computed properties * such as an array of their keys, status flags, timestamps, etc. */ interface IEntityState { entities: IEntityDictionary; ids: EntityIdentity[]; selections?: IEntitySelections; edits?: IEntityEdits; paging?: IEntityPaging; tracking?: IEntityTracking; } declare enum EntityActionTypes { Load = "[Entity] (Generic) Load", LoadIfNecessary = "[Entity] (Generic) Load (If Necessary)", LoadSuccess = "[Entity] (Generic) Load: Success", LoadFailure = "[Entity] (Generic) Load: Failure", LoadMany = "[Entity] (Generic) Load Many", LoadManyIfNecessary = "[Entity] (Generic) Load Many (If Necessary)", LoadManySuccess = "[Entity] (Generic) Load Many: Success", LoadManyFailure = "[Entity] (Generic) Load Many: Failure", LoadAll = "[Entity] (Generic) Load All", LoadAllIfNecessary = "[Entity] (Generic) Load All (If Necessary)", LoadAllSuccess = "[Entity] (Generic) Load All: Success", LoadAllFailure = "[Entity] (Generic) Load All: Failure", LoadPage = "[Entity] (Generic) Load Page", LoadPageIfNecessary = "[Entity] (Generic) Load Page (If Necessary)", LoadPageSuccess = "[Entity] (Generic) Load Page: Success", LoadPageFailure = "[Entity] (Generic) Load Page: Failure", LoadRange = "[Entity] (Generic) Load Range", LoadRangeIfNecessary = "[Entity] (Generic) Load Range (If Necessary)", LoadRangeSuccess = "[Entity] (Generic) Load Range: Success", LoadRangeFailure = "[Entity] (Generic) Load Range: Failure", Create = "[Entity] (Generic) Create", CreateSuccess = "[Entity] (Generic) Create: Success", CreateFailure = "[Entity] (Generic) Create: Failure", CreateMany = "[Entity] (Generic) Create Many", CreateManySuccess = "[Entity] (Generic) Create Many: Success", CreateManyFailure = "[Entity] (Generic) Create Many: Failure", Update = "[Entity] (Generic) Update", UpdateSuccess = "[Entity] (Generic) Update: Success", UpdateFailure = "[Entity] (Generic) Update: Failure", UpdateMany = "[Entity] (Generic) Update Many", UpdateManySuccess = "[Entity] (Generic) Update Many: Success", UpdateManyFailure = "[Entity] (Generic) Update Many: Failure", Upsert = "[Entity] (Generic) Upsert", UpsertSuccess = "[Entity] (Generic) Upsert: Success", UpsertFailure = "[Entity] (Generic) Upsert: Failure", UpsertMany = "[Entity] (Generic) Upsert Many", UpsertManySuccess = "[Entity] (Generic) Upsert Many: Success", UpsertManyFailure = "[Entity] (Generic) Upsert Many: Failure", Replace = "[Entity] (Generic) Replace", ReplaceSuccess = "[Entity] (Generic) Replace: Success", ReplaceFailure = "[Entity] (Generic) Replace: Failure", ReplaceMany = "[Entity] (Generic) Replace Many", ReplaceManySuccess = "[Entity] (Generic) Replace Many: Success", ReplaceManyFailure = "[Entity] (Generic) Replace Many: Failure", Delete = "[Entity] (Generic) Delete", DeleteSuccess = "[Entity] (Generic) Delete: Success", DeleteFailure = "[Entity] (Generic) Delete: Failure", DeleteMany = "[Entity] (Generic) Delete Many", DeleteManySuccess = "[Entity] (Generic) Delete Many: Success", DeleteManyFailure = "[Entity] (Generic) Delete Many: Failure", DeleteByKey = "[Entity] (Generic) Delete by key", DeleteByKeySuccess = "[Entity] (Generic) Delete by key: Success", DeleteByKeyFailure = "[Entity] (Generic) Delete by key: Failure", DeleteManyByKeys = "[Entity] (Generic) Delete many by keys", DeleteManyByKeysSuccess = "[Entity] (Generic) Delete many by keys: Success", DeleteManyByKeysFailure = "[Entity] (Generic) Delete many by keys: Failure", Clear = "[Entity] (Generic) Clear", Select = "[Entity] (Generic) Select", SelectByKey = "[Entity] (Generic) Select by Key", Selected = "[Entity] (Generic) Selection", SelectMany = "[Entity] (Generic) Select Many", SelectMore = "[Entity] (Generic) Select More", SelectManyByKeys = "[Entity] (Generic) Select Many by Keys", SelectMoreByKeys = "[Entity] (Generic) Select More by Keys", SelectedMany = "[Entity] (Generic) Selection of Many", SelectedMore = "[Entity] (Generic) Selection of More", Deselect = "[Entity] (Generic) Deselect", Deselected = "[Entity] (Generic) Deselection", DeselectMany = "[Entity] (Generic) Deselect of Many", DeselectManyByKeys = "[Entity] (Generic) Deselect of Many by Keys", DeselectAll = "[Entity] (Generic) Deselect of All", DeselectedMany = "[Entity] (Generic) Deselection of Many", EditNew = "[Entity] (Generic) Edit New", Edit = "[Entity] (Generic) Edit", EditByKey = "[Entity] (Generic) Edit by Key", Edited = "[Entity] (Generic) Edited", EditedByKey = "[Entity] (Generic) Edited by Key", Change = "[Entity] (Generic) Change", Changed = "[Entity] (Generic) Changed", EndEdit = "[Entity] (Generic) Edit: End", EditEnded = "[Entity] (Generic) Edit: Ended" } type IEffectExclusions = { readonly [action in any | EntityActionTypes]: boolean; }; /** * Defines effect exceptions for the decorated model. */ interface IEffectExcept { except?: (...actions: EntityActionTypes[]) => IEffectExclusions; } /** * Defines an entity data transformer capable of transforming data to and from the server. */ interface IEntityTransformer { fromServer?: (data: any, criteria?: any) => any; toServer?: (entity: any, criteria?: any) => any; } type EntityComparer = (a: any, b: any) => number; interface IEntityComparerMap { [key: string]: EntityComparer | string; } interface IEntityNames { modelName: string; pluralName?: string; uriName?: string; } declare enum EntityAge { Minute = 60, Hour = 3600, QuarterDay = 21600, HalfDay = 43200, Day = 86400, Week = 604800 } /** * The options that may be configured for a decorated entity model. * * @property comparer - (optional) A default comparer for sorting entities on selection * @property comparers - (optional) A set of comparer functions or named comparer references for sorting entities * @property transform - (optional) A set of entity transform objects that may be composed, in order, to transform the entity * @property excludeEffects - (optional) The effect exclusion config * @see IEffectExclusions * @property defaultMaxAge - (optional) A default maximum age, in seconds, after which load*IfNecessary actions will always load */ interface IEntityOptions extends IEntityNames { comparer?: EntityComparer; comparers?: IEntityComparerMap; transform?: IEntityTransformer[]; excludeEffects?: IEffectExclusions | IEffectExcept; defaultMaxAge?: number | EntityAge; } /** * Descriptor of an Entity model and related metadata. */ interface IEntityInfo extends IEntityOptions { modelType: new () => any; } /** * Constructor type for an Entity model. */ type TNew = new () => TModel; interface ICorrelatedAction { correlationId: string; } interface IEntityAction extends Action, ICorrelatedAction { actionType: EntityActionTypes; info: IEntityInfo; } /** * Structure for all of this library's actions */ declare abstract class EntityAction implements IEntityAction { actionType: EntityActionTypes; correlationId: string; type: string; info: IEntityInfo; protected constructor(type: TNew, actionType: EntityActionTypes, correlationId?: string); } /** * Clears all entities for this model from state */ declare class Clear extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * Creates a single entity, corresponding to HTTP POST operation */ declare class Create extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class CreateSuccess extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class CreateFailure extends EntityAction { error: any; entity: TModel; criteria?: any; constructor(type: new () => TModel, error: any, entity: TModel, criteria?: any, correlationId?: string); } /** * Creates many entities, corresponding to HTTP POST operation */ declare class CreateMany extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class CreateManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class CreateManyFailure extends EntityAction { error: any; entities: TModel[]; criteria?: any; constructor(type: new () => TModel, error: any, entities: TModel[], criteria?: any, correlationId?: string); } /** * Deletes a single entity, corresponding to HTTP DELETE operation */ declare class Delete extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class DeleteSuccess extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class DeleteFailure extends EntityAction { error: any; entity: TModel; criteria?: any; constructor(type: new () => TModel, error: any, entity: TModel, criteria?: any, correlationId?: string); } /** * Deletes many entities, corresponding to HTTP DELETE operation */ declare class DeleteMany extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class DeleteManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class DeleteManyFailure extends EntityAction { error: any; entities: TModel[]; criteria?: any; constructor(type: new () => TModel, error: any, entities: TModel[], criteria?: any, correlationId?: string); } /** * Deletes a single entity by key, corresponding to HTTP DELETE operation */ declare class DeleteByKey extends EntityAction { key: EntityIdentity; criteria?: any; constructor(type: new () => TModel, key: EntityIdentity, criteria?: any, correlationId?: string); } declare class DeleteByKeySuccess extends EntityAction { key: EntityIdentity; criteria?: any; constructor(type: new () => TModel, key: EntityIdentity, criteria?: any, correlationId?: string); } declare class DeleteByKeyFailure extends EntityAction { error: any; key: EntityIdentity; criteria?: any; constructor(type: new () => TModel, error: any, key: EntityIdentity, criteria?: any, correlationId?: string); } /** * Deletes many entities, corresponding to HTTP DELETE operation */ declare class DeleteManyByKeys extends EntityAction { keys: EntityIdentity[]; criteria?: any; constructor(type: new () => TModel, keys: EntityIdentity[], criteria?: any, correlationId?: string); } declare class DeleteManyByKeysSuccess extends EntityAction { keys: EntityIdentity[]; criteria?: any; constructor(type: new () => TModel, keys: EntityIdentity[], criteria?: any, correlationId?: string); } declare class DeleteManyByKeysFailure extends EntityAction { error: any; keys: EntityIdentity[]; criteria?: any; constructor(type: new () => TModel, error: any, keys: EntityIdentity[], criteria?: any, correlationId?: string); } /** * De-selects a single entity in the store */ declare class Deselect extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * De-selects many entities in the store */ declare class DeselectMany extends EntityAction { entities: TModel[]; constructor(type: new () => TModel, entities: TModel[], correlationId?: string); } /** * De-selects many entities in the store by entity keys */ declare class DeselectManyByKeys extends EntityAction { entitiesKeys: EntityIdentity[]; constructor(type: new () => TModel, entitiesKeys: EntityIdentity[], correlationId?: string); } /** * De-selects all entities in the store */ declare class DeselectAll extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * Indicates the de-selection of a single entity in the store */ declare class Deselected extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * Indicates the de-selection of many entities in the store */ declare class DeselectedMany extends EntityAction { entities: Array | null; constructor(type: new () => TModel, entities: Array | null, correlationId?: string); } /** * Tracks a new entity as being edited in the store */ declare class EditNew extends EntityAction { entity?: Partial; constructor(type: new () => TModel, entity?: Partial, correlationId?: string); } /** * Tracks an entity as being edited in the store */ declare class Edit extends EntityAction { entity: Partial; constructor(type: new () => TModel, entity: Partial, correlationId?: string); } /** * Tracks an entity (by its key) as being edited in the store */ declare class EditByKey extends EntityAction { key: EntityIdentity; constructor(type: new () => TModel, key: EntityIdentity, correlationId?: string); } /** * Indicates an entity is being tracked as edited in the store */ declare class Edited extends EntityAction { entity: Partial; constructor(type: new () => TModel, entity: Partial, correlationId?: string); } /** * Indicates an entity (by its key) is being tracked as edited in the store */ declare class EditedByKey extends EntityAction { key: EntityIdentity; constructor(type: new () => TModel, key: EntityIdentity, correlationId?: string); } /** * Indicates a change is occurring to the edited entity in the store */ declare class Change extends EntityAction { entity: Partial; constructor(type: new () => TModel, entity: Partial, correlationId?: string); } /** * Indicates a change has occurred to the edited entity in the store */ declare class Changed extends EntityAction { entity: Partial; constructor(type: new () => TModel, entity: Partial, correlationId?: string); } /** * Ends editing of currently edited entity and clears it from state */ declare class EndEdit extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * Indicates editing of currently edited entity has ended */ declare class EditEnded extends EntityAction { constructor(type: new () => TModel, correlationId?: string); } /** * Loads a single instance of an entity if necessary * HTTP GET /entity/:id operation * * @remarks: * This action will only load the entity if it does not exist in state, referenced by key * This is an alternative initiation action that will ultimately result in Load being dispatched * * @param type - The entity model decorated with @Entity * @param keys - (optional) The keys of the entity you wish to load * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadIfNecessary extends EntityAction { keys?: any; maxAge?: number; criteria?: any; constructor(type: new () => TModel, keys?: any, maxAge?: number, criteria?: any, correlationId?: string); } /** * Loads a single instance of an entity * HTTP GET /entity/:id * * @remarks * The loaded entity will replace any existing entity in state * * @param type - The entity model decorated with @Entity * @param keys - (optional) The keys of the entity you wish to load * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class Load extends EntityAction { keys?: any; criteria?: any; constructor(type: new () => TModel, keys?: any, criteria?: any, correlationId?: string); } /** * Handles a successful response for loading an entity * HTTP GET /entity/:id * * @param type - The entity model decorated with @Entity * @param entity - The entity that was loaded * @param keys - (optional) The keys of the entity you loaded * @param criteria - (optional) The custom criteria from the initial load action * @param correlationId - (optional) The correlationId for this action; correlates to initial load action */ declare class LoadSuccess extends EntityAction { entity: TModel; keys?: any; criteria?: any; constructor(type: new () => TModel, entity: TModel, keys?: any, criteria?: any, correlationId?: string); } /** * Handles an error response when loading an entity * HTTP GET /entity/:id * * @param type - The entity model decorated with @Entity * @param error - The error object that was thrown * @param keys - The keys of the entity you loaded * @param criteria - (optional) The custom criteria from the initial load action * @param correlationId - (optional) The correlationId for this action; correlates to initial load action */ declare class LoadFailure extends EntityAction { error: any; keys?: any; criteria?: any; constructor(type: new () => TModel, error: any, keys?: any, criteria?: any, correlationId?: string); } /** * Loads all instances of an entity if necessary * HTTP GET /entity * * @remarks: * This action will only load the entity if there is no previous loadedAt date or any entities in state * This is an alternative initiation action that will ultimately result in Load being dispatched * * @param type - The entity model decorated with @Entity * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadAllIfNecessary extends EntityAction { maxAge?: number; criteria?: any; constructor(type: new () => TModel, maxAge?: number, criteria?: any, correlationId?: string); } /** * Loads all instances of an entity * HTTP GET /entity * * @remarks: * Replaces all entities for this model in state. * * @param type - The entity model decorated with @Entity * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadAll extends EntityAction { criteria?: any; constructor(type: new () => TModel, criteria?: any, correlationId?: string); } /** * Handles a successful response for loading all entities * HTTP GET /entity * * @param type - The entity model decorated with @Entity * @param entities - The entities that were loaded * @param criteria - (optional) The custom criteria from the initial load all action * @param correlationId - (optional) The correlationId for this action; correlates to initial load all action */ declare class LoadAllSuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } /** * Handles an error response when loading all entities * HTTP GET /entity * * @param type - The entity model decorated with @Entity * @param error - (optional) The error object that was thrown * @param criteria - (optional) The custom criteria from the initial load all action * @param correlationId - (optional) The correlationId for this action; correlates to initial load all action */ declare class LoadAllFailure extends EntityAction { error: any; criteria?: any; constructor(type: new () => TModel, error: any, criteria?: any, correlationId?: string); } /** * Loads all instances of an entity if necessary * HTTP GET /entity * * @remarks: * This action will only load the entity if there is no previous loadedAt date or any entities in state * This is an alternative initiation action that will ultimately result in Load being dispatched * * @param type - The entity model decorated with @Entity * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadManyIfNecessary extends EntityAction { maxAge?: number; criteria?: any; constructor(type: new () => TModel, maxAge?: number, criteria?: any, correlationId?: string); } /** * Loads many instances of an entity * HTTP GET /entity * * @remarks: * Replaces many entities for this model in state. Loaded entities will be merged into state, updating * existing entities (by key) or adding new entities (key not found in state). * * @param type - The entity model decorated with @Entity * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadMany extends EntityAction { criteria?: any; constructor(type: new () => TModel, criteria?: any, correlationId?: string); } /** * Handles a successful response for loading many entities * HTTP GET /entity * * @param type - The entity model decorated with @Entity * @param entities - The entities that were loaded * @param criteria - (optional) The custom criteria from the initial load many action * @param correlationId - (optional) The correlationId for this action; correlates to initial load many action */ declare class LoadManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } /** * Handles an error response when loading many entities * HTTP GET /entity * * @param type - The entity model decorated with @Entity * @param error - (optional) The error object that was thrown * @param criteria - (optional) The custom criteria from the initial load many action * @param correlationId - (optional) The correlationId for this action; correlates to initial load many action */ declare class LoadManyFailure extends EntityAction { error: any; criteria?: any; constructor(type: new () => TModel, error: any, criteria?: any, correlationId?: string); } /** * Loads instances of a page of entities if necessary * HTTP GET /entity?page&size (etc.) * * @remarks: * This action will only load the entity if there is no previous loadedAt date or entities in state, * or if the current page information for entities in state does not match the page being loaded * This is an alternative initiation action that will ultimately result in Load being dispatched * * @param type - The entity model decorated with @Entity * @param page - The information about the page to load * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadPageIfNecessary extends EntityAction { page: Page; maxAge?: number; criteria?: any; constructor(type: new () => TModel, page: Page, maxAge?: number, criteria?: any, correlationId?: string); } /** * Loads a single page of an entity * HTTP GET /entity?page&size (etc.) * * @remarks * The loaded page of entities will replace all entities for this model in state * Will update the current page info in state * * @param type - The entity model decorated with @Entity * @param page - The information about the page to load * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadPage extends EntityAction { page: Page; criteria?: any; constructor(type: new () => TModel, page: Page, criteria?: any, correlationId?: string); } /** * Handles a successful response for loading a page of entities * HTTP GET /entity?page&size (etc.) * * @param type - The entity model decorated with @Entity * @param entities - The entities that were loaded * @param pageInfo - The information about the page loaded * @param criteria - (optional) The custom criteria from the initial load page action * @param correlationId - (optional) The correlationId for this action; correlates to initial load page action */ declare class LoadPageSuccess extends EntityAction { entities: TModel[]; pageInfo: IPageInfo; criteria?: any; constructor(type: new () => TModel, entities: TModel[], pageInfo: IPageInfo, criteria?: any, correlationId?: string); } /** * Handles an error response when loading a page of entities * HTTP GET /entity?page&size (etc.) * * @param type - The entity model decorated with @Entity * @param error - The error object that was thrown * @param page - The page you tried to load * @param criteria - (optional) The custom criteria from the initial load page action * @param correlationId - (optional) The correlationId for this action; correlates to initial load page action */ declare class LoadPageFailure extends EntityAction { error: any; page: Page; criteria?: any; constructor(type: new () => TModel, error: any, page: Page, criteria?: any, correlationId?: string); } /** * Loads instances of a range of entities if necessary * HTTP GET /entity?start&end|first&last|skip&take (etc.) * * @remarks: * This action will only load the entity if there is no previous loadedAt date or entities in state, * or if the current range information for entities in state does not intersect the range being loaded * This is an alternative initiation action that will ultimately result in Load being dispatched * * @param type - The entity model decorated with @Entity * @param range - The information about the range to load * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadRangeIfNecessary extends EntityAction { range: Range; maxAge?: number; criteria?: any; constructor(type: new () => TModel, range: Range, maxAge?: number, criteria?: any, correlationId?: string); } /** * Loads instances of a range of entities * HTTP GET /entity?start&end|first&last|skip&take (etc.) * * @remarks: * The loaded entities will be added to any range of entities already in state * Will update the current range info in state * * @param type - The entity model decorated with @Entity * @param range - The information about the range to load * @param maxAge - (optional) The max age of the entity, after which load will be performed regardless * @param criteria - (optional) The custom criteria for this action * @param correlationId - (optional) A custom correlation id for this action; Use to correlate subsequent result actions */ declare class LoadRange extends EntityAction { range: Range; criteria?: any; constructor(type: new () => TModel, range: Range, criteria?: any, correlationId?: string); } /** * Handles a successful response for loading a range of entities * HTTP GET /entity?start&end|first&last|skip&take (etc.) * * @param type - The entity model decorated with @Entity * @param entities - The entities that were loaded * @param rangeInfo - The information about the range loaded * @param criteria - (optional) The custom criteria from the initial load range action * @param correlationId - (optional) The correlationId for this action; correlates to initial load range action */ declare class LoadRangeSuccess extends EntityAction { entities: TModel[]; rangeInfo: IRangeInfo; criteria?: any; constructor(type: new () => TModel, entities: TModel[], rangeInfo: IRangeInfo, criteria?: any, correlationId?: string); } /** * Handles an error response when loading a page of entities * HTTP GET /entity?start&end|first&last|skip&take (etc.) * * @param type - The entity model decorated with @Entity * @param error - The error object that was thrown * @param range - The range you tried to load * @param criteria - (optional) The custom criteria from the initial load range action * @param correlationId - (optional) The correlationId for this action; correlates to initial load range action */ declare class LoadRangeFailure extends EntityAction { error: any; range: Range; criteria?: any; constructor(type: new () => TModel, error: any, range: Range, criteria?: any, correlationId?: string); } /** * Replaces a single entity, corresponding to HTTP PUT operation. * * PUT: Replace the entity with the one supplied in the request */ declare class Replace extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class ReplaceSuccess extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class ReplaceFailure extends EntityAction { error: any; entity: TModel; criteria?: any; constructor(type: new () => TModel, error: any, entity: TModel, criteria?: any, correlationId?: string); } /** * Replaces many entities, corresponding to HTTP PUT operation. * * PUT: Replace the entities with the ones supplied in the request */ declare class ReplaceMany extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class ReplaceManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class ReplaceManyFailure extends EntityAction { error: any; entities: TModel[]; criteria?: any; constructor(type: new () => TModel, error: any, entities: TModel[], criteria?: any, correlationId?: string); } /** * Selects a single entity in the store by the entity model */ declare class Select extends EntityAction { entity: TModel; constructor(type: new () => TModel, entity: TModel, correlationId?: string); } /** * Selects a single entity in the store by the entity key */ declare class SelectByKey extends EntityAction { entityKey: EntityIdentity; constructor(type: new () => TModel, entityKey: EntityIdentity, correlationId?: string); } /** * Selects many entities in the store by the entity models */ declare class SelectMany extends EntityAction { entities: TModel[]; constructor(type: new () => TModel, entities: TModel[], correlationId?: string); } /** * Selects more entities in the store by the entity models */ declare class SelectMore extends EntityAction { entities: TModel[]; constructor(type: new () => TModel, entities: TModel[], correlationId?: string); } /** * Selects many entities in the store by the entity keys */ declare class SelectManyByKeys extends EntityAction { entitiesKeys: EntityIdentity[]; constructor(type: new () => TModel, entitiesKeys: EntityIdentity[], correlationId?: string); } /** * Selects more entities in the store by the entity keys */ declare class SelectMoreByKeys extends EntityAction { entitiesKeys: EntityIdentity[]; constructor(type: new () => TModel, entitiesKeys: EntityIdentity[], correlationId?: string); } /** * Indicates the selection of a single entity in the store */ declare class Selected extends EntityAction { entity: TModel | EntityIdentity; constructor(type: new () => TModel, entity: TModel | EntityIdentity, correlationId?: string); } /** * Indicates the selection of many entities in the store */ declare class SelectedMany extends EntityAction { entities: Array; constructor(type: new () => TModel, entities: Array, correlationId?: string); } /** * Indicates the selection of more entities in the store */ declare class SelectedMore extends EntityAction { entities: Array; constructor(type: new () => TModel, entities: Array, correlationId?: string); } /** * Updates a single entity, corresponding to HTTP PATCH operation. * * PATCH: Update just the supplied attributes of the entity */ declare class Update extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class UpdateSuccess extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class UpdateFailure extends EntityAction { error: any; entity: TModel; criteria?: any; constructor(type: new () => TModel, error: any, entity: TModel, criteria?: any, correlationId?: string); } /** * Updates many entities, corresponding to HTTP PATCH operation. * * PATCH: Update just the supplied attributes of the entities */ declare class UpdateMany extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class UpdateManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class UpdateManyFailure extends EntityAction { error: any; entities: TModel[]; criteria?: any; constructor(type: new () => TModel, error: any, entities: TModel[], criteria?: any, correlationId?: string); } /** * Updates or inserts a single entity, corresponding to HTTP PUT or POST operation. * */ declare class Upsert extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class UpsertSuccess extends EntityAction { entity: TModel; criteria?: any; constructor(type: new () => TModel, entity: TModel, criteria?: any, correlationId?: string); } declare class UpsertFailure extends EntityAction { error: any; entity: TModel; criteria?: any; constructor(type: new () => TModel, error: any, entity: TModel, criteria?: any, correlationId?: string); } /** * Updates or inserts many entities, corresponding to HTTP PUT or POST operation. * */ declare class UpsertMany extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class UpsertManySuccess extends EntityAction { entities: TModel[]; criteria?: any; constructor(type: new () => TModel, entities: TModel[], criteria?: any, correlationId?: string); } declare class UpsertManyFailure extends EntityAction { error: any; entities: TModel[]; criteria?: any; constructor(type: new () => TModel, error: any, entities: TModel[], criteria?: any, correlationId?: string); } interface CorrelatedProps { correlationId?: string; } interface StandardProps extends CorrelatedProps { criteria?: any; } declare const NAE_TYPE_ACTION_CACHE = "__nae_type_action_cache"; interface CreateProps extends StandardProps { entity: TModel; } interface CreateFailureProps extends StandardProps { error: any; entity: TModel; } interface CreateManyProps extends StandardProps { entities: TModel[]; } interface CreateManyFailureProps extends StandardProps { error: any; entities: TModel[]; } interface DeleteByKeyProps extends StandardProps { key: EntityIdentity; } interface DeleteByKeyFailureProps extends StandardProps { error: any; key: EntityIdentity; } interface DeleteManyByKeysProps extends StandardProps { keys: EntityIdentity[]; } interface DeleteManyByKeysFailureProps extends StandardProps { error: any; keys: EntityIdentity[]; } interface DeleteProps extends StandardProps { entity: TModel; } interface DeleteFailureProps extends StandardProps { error: any; entity: TModel; } interface DeleteManyProps extends StandardProps { entities: TModel[]; } interface DeleteManyFailureProps extends StandardProps { error: any; entities: TModel[]; } interface DeselectManyProps extends CorrelatedProps { entities: TModel[]; } interface DeselectManyByKeysProps extends CorrelatedProps { keys: EntityIdentity[]; } interface DeselectedManyProps extends CorrelatedProps { entities: Array; } interface EditNewProps extends CorrelatedProps { entity?: Partial; } interface EditProps extends CorrelatedProps { entity: Partial; } interface EditByKeyProps extends CorrelatedProps { key: EntityIdentity; } interface LoadAllIfNecessaryProps extends StandardProps { maxAge?: number; } interface LoadAllSuccessProps extends StandardProps { entities: TModel[]; } interface LoadAllFailureProps extends StandardProps { error: any; } interface LoadProps extends StandardProps { keys?: any; } interface LoadIfNecessaryProps extends LoadProps { maxAge?: number; } interface LoadSuccessProps extends LoadProps { entity: TModel; } interface LoadFailureProps extends LoadProps { error: any; } interface LoadManyIfNecessaryProps extends StandardProps { maxAge?: number; } interface LoadManySuccessProps extends StandardProps { entities: TModel[]; } interface LoadManyFailureProps extends StandardProps { error: any; } interface LoadPageProps extends StandardProps { page: Page; } interface LoadPageIfNecessaryProps extends LoadPageProps { maxAge?: number; } interface LoadPageSuccessProps extends StandardProps { entities: TModel[]; pageInfo: IPageInfo; } interface LoadPageFailureProps extends StandardProps { error: any; page: Page; } interface LoadRangeProps extends StandardProps { range: Range; } interface LoadRangeIfNecessaryProps extends LoadRangeProps { maxAge?: number; } interface LoadRangeSuccessProps extends StandardProps { entities: TModel[]; rangeInfo: IRangeInfo; } interface LoadRangeFailureProps extends StandardProps { error: any; range: Range; } interface ReplaceProps extends StandardProps { entity: TModel; } interface ReplaceFailureProps extends StandardProps { error: any; entity: TModel; } interface ReplaceManyProps extends StandardProps { entities: TModel[]; } interface ReplaceManyFailureProps extends StandardProps { error: any; entities: TModel[]; } interface SelectProps extends CorrelatedProps { entity: TModel; } interface SelectByKeyProps extends CorrelatedProps { key: EntityIdentity; } interface SelectManyProps extends CorrelatedProps { entities: TModel[]; } interface SelectManyByKeysProps extends CorrelatedProps { keys: EntityIdentity[]; } interface SelectedManyProps extends CorrelatedProps { entities: Array; } interface UpdateProps extends StandardProps { entity: TModel; } interface UpdateFailureProps extends StandardProps { error: any; entity: TModel; } interface UpdateManyProps extends StandardProps { entities: TModel[]; } interface UpdateManyFailureProps extends StandardProps { error: any; entities: TModel[]; } interface UpsertProps extends StandardProps { entity: TModel; } interface UpsertFailureProps extends StandardProps { error: any; entity: TModel; } interface UpsertManyProps extends StandardProps { entities: TModel[]; } interface UpsertManyFailureProps extends StandardProps { error: any; entities: TModel[]; } interface IActionMap { loadIfNecessary: ActionCreator LoadIfNecessary>; load: ActionCreator Load>; loadSuccess: ActionCreator) => LoadSuccess>; loadFailure: ActionCreator) => LoadFailure>; loadAllIfNecessary: ActionCreator LoadAllIfNecessary>; loadAll: ActionCreator LoadAll>; loadAllSuccess: ActionCreator) => LoadAllSuccess>; loadAllFailure: ActionCreator) => LoadAllFailure>; loadManyIfNecessary: ActionCreator LoadManyIfNecessary>; loadMany: ActionCreator LoadMany>; loadManySuccess: ActionCreator) => LoadManySuccess>; loadManyFailure: ActionCreator) => LoadManyFailure>; loadPageIfNecessary: ActionCreator LoadPageIfNecessary>; loadPage: ActionCreator LoadPage>; loadPageSuccess: ActionCreator) => LoadPageSuccess>; loadPageFailure: ActionCreator) => LoadPageFailure>; loadRangeIfNecessary: ActionCreator LoadRangeIfNecessary>; loadRange: ActionCreator LoadRange>; loadRangeSuccess: ActionCreator) => LoadRangeSuccess>; loadRangeFailure: ActionCreator) => LoadRangeFailure>; create: ActionCreator) => Create>; createSuccess: ActionCreator) => CreateSuccess>; createFailure: ActionCreator) => CreateFailure>; createMany: ActionCreator) => CreateMany>; createManySuccess: ActionCreator) => CreateManySuccess>; createManyFailure: ActionCreator) => CreateManyFailure>; update: ActionCreator) => Update>; updateSuccess: ActionCreator) => UpdateSuccess>; updateFailure: ActionCreator) => UpdateFailure>; updateMany: ActionCreator) => UpdateMany>; updateManySuccess: ActionCreator) => UpdateManySuccess>; updateManyFailure: ActionCreator) => UpdateManyFailure>; upsert: ActionCreator) => Upsert>; upsertSuccess: ActionCreator) => UpsertSuccess>; upsertFailure: ActionCreator) => UpsertFailure>; upsertMany: ActionCreator) => UpsertMany>; upsertManySuccess: ActionCreator) => UpsertManySuccess>; upsertManyFailure: ActionCreator) => UpsertManyFailure>; replace: ActionCreator) => Replace>; replaceSuccess: ActionCreator) => ReplaceSuccess>; replaceFailure: ActionCreator) => ReplaceFailure>; replaceMany: ActionCreator) => ReplaceMany>; replaceManySuccess: ActionCreator) => ReplaceManySuccess>; replaceManyFailure: ActionCreator) => ReplaceManyFailure>; delete: ActionCreator) => Delete>; deleteSuccess: ActionCreator) => DeleteSuccess>; deleteFailure: ActionCreator) => DeleteFailure>; deleteMany: ActionCreator) => DeleteMany>; deleteManySuccess: ActionCreator) => DeleteManySuccess>; deleteManyFailure: ActionCreator) => DeleteManyFailure>; deleteByKey: ActionCreator) => DeleteByKey>; deleteByKeySuccess: ActionCreator) => DeleteByKeySuccess>; deleteByKeyFailure: ActionCreator) => DeleteByKeyFailure>; deleteManyByKeys: ActionCreator) => DeleteManyByKeys>; deleteManyByKeysSuccess: ActionCreator) => DeleteManyByKeysSuccess>; deleteManyByKeysFailure: ActionCreator) => DeleteManyByKeysFailure>; clear: ActionCreator Clear>; deselect: ActionCreator Deselect>; deselectMany: ActionCreator) => DeselectMany>; deselectManyByKeys: ActionCreator DeselectManyByKeys>; deselectAll: ActionCreator DeselectAll>; deselected: ActionCreator Deselected>; deselectedMany: ActionCreator) => DeselectedMany>; select: ActionCreator) => Select>; selectByKey: ActionCreator SelectByKey>; selectMany: ActionCreator) => SelectMany>; selectMore: ActionCreator) => SelectMore>; selectManyByKeys: ActionCreator SelectManyByKeys>; selectMoreByKeys: ActionCreator SelectMoreByKeys>; selected: ActionCreator