ngrx-entity-crud 15.0.2 → 15.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/esm2020/lib/models.mjs +1 -1
  2. package/fesm2015/ngrx-entity-crud.mjs.map +1 -1
  3. package/fesm2020/ngrx-entity-crud.mjs.map +1 -1
  4. package/lib/models.d.ts +4 -0
  5. package/lib/models.d.ts.map +1 -1
  6. package/package.json +1 -1
package/esm2020/lib/models.mjs CHANGED
@@ -14,4 +14,4 @@ export var ActionEnum;
14
14
  ActionEnum["FAILURE"] = "Failure";
15
15
  ActionEnum["SUCCESS"] = "Success";
16
16
  })(ActionEnum || (ActionEnum = {}));
17
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../projects/ngrx-entity-crud/src/lib/models.ts"],"names":[],"mappings":"AAwDA,MAAM,CAAN,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6BAAiB,CAAA;IACjB,6BAAiB,CAAA;IACjB,6BAAiB,CAAA;IACjB,yBAAa,CAAA;IACb,6BAAiB,CAAA;IACjB,2BAAe,CAAA;AACjB,CAAC,EAPW,QAAQ,KAAR,QAAQ,QAOnB;AAED,MAAM,CAAN,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,mCAAqB,CAAA;IACrB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;AACrB,CAAC,EALW,UAAU,KAAV,UAAU,QAKrB","sourcesContent":["import {EntityAdapter, EntityState} from '@ngrx/entity';\nimport {Action, ActionCreator, MemoizedSelector} from '@ngrx/store';\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/store/src/models, da errori nei progetti dove viene utilizzato.\nexport declare interface TypedAction<T extends string> extends Action {\n  readonly type: T;\n}\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport interface DictionaryNum<T> {\n  [id: number]: T | undefined;\n}\n\nexport declare abstract class Dictionary<T> implements DictionaryNum<T> {\n  [id: string]: T | undefined;\n}\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport type IdSelectorStr<T> = (model: T) => string;\nexport type IdSelectorNum<T> = (model: T) => number;\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport type IdSelector<T> = IdSelectorStr<T> | IdSelectorNum<T>;\n\n// per evitare l'importazione\n// import {Comparer, EntityAdapter, IdSelector} from '@ngrx/entity/src/models';\n// ho copiato i seguenti type\nexport declare type ComparerStr<T> = (a: T, b: T) => string;\nexport declare type Comparer<T> = (a: T, b: T) => number;\n\nexport interface EntitySelectors<T, V> {\n  /**\n   * - used to select a group of ids\n   * @param (state: V) => string[] | number[]\n   */\n  selectIds: (state: V) => string[] | number[];\n  /**\n   * - used to select a group of entities\n   * @param (state: V) => Dictionary<T>\n   */\n  selectEntities: (state: V) => Dictionary<T>;\n  /**\n   * - used to select all items\n   * @param (state: V) => T[]\n   */\n  selectAll: (state: V) => T[];\n  /**\n   * - used to select the sum of items\n   * @param (state: V) => number\n   */\n  selectTotal: (state: V) => number;\n}\n\nexport enum CrudEnum {\n  SEARCH = 'Search',\n  DELETE = 'Delete',\n  CREATE = 'Create',\n  EDIT = 'Edit',\n  SELECT = 'Select',\n  RESET = 'Reset',\n}\n\nexport enum ActionEnum {\n  RESPONSE = 'Response',\n  REQUEST = 'Request',\n  FAILURE = 'Failure',\n  SUCCESS = 'Success',\n}\n\nexport interface OptRequestBase {\n  /**\n   * is added to the service route,\n   * in some cases it is necessary to invoke a sub-route.\n   * if the service was \"user\" and the sub-route \"user/accept\":\n   * path:[\"accept\"]\n   */\n  path?: any[];\n  /**\n   * Dispatched actions in case of error.\n   */\n  onFault?: Action[];\n  /**\n   * Dispatched actions in the event of a positive response\n   */\n  onResult?: Action[];\n\n  /**\n   * se true, al completamento della chiamata asincrona, verrà inviata un'azione di tipo Response,\n   * contenente le informazioni sulla chiamata e la risposta.\n   * In questo modo sarà possibile analizzare l'andamento\n   */\n  dispatchResponse?: boolean;\n}\n\n/**\n * - criteria: ICriteria: criteria di ricerca\n */\nexport interface ICriteria<QP = any> extends OptRequestBase {\n  /**\n   *\n   * \"REFRESH\" the store will be deleted before making the remote call, all the elements will be added to the call result.\n   *\n   */\n  mode?: 'REFRESH' | 'upsertMany' | 'upsertMany-updateMany-selected' | 'addAll';\n\n  queryParams?: QP;\n}\n\nexport interface OptRequest<T = any> extends OptRequestBase {\n  mutationParams: T;\n  /**\n   * options optional\n   */\n  options?: any;\n}\n\nexport interface OptResponse<T> {\n  actionType: string;\n  response: Response<T>;\n  request: ICriteria | OptRequest;\n}\n\nexport interface OptEffect {\n  /**\n   * per ogni stringa presente nell'attributo, verrà spedita una notifica Response.\n   * in questo modo, chi invia la notifica potrà poi filtrare i dati in base alla chiave inviata.\n   */\n  dispatchResponse?: boolean;\n}\n\nexport interface Response<T> {\n  data: T | any;\n  hasError: boolean;\n  message: string;\n}\n\nexport interface FilterMetadata {\n  value?: any;\n  matchMode?: string;\n  renderFunction?: (value: any) => string;\n}\n\nexport interface CrudBaseState<T> {\n  error: string;\n  isLoading: boolean;\n  isLoaded: boolean;\n  lastCriteria: ICriteria;\n  responses: OptResponse<T>[];\n}\n\nexport interface SingleCrudState<T> extends CrudBaseState<T> {\n  item: T\n}\n\nexport interface CrudState<T> extends CrudBaseState<T>, EntityState<T> {\n  filters: { [s: string]: FilterMetadata; };\n  idsSelected: string[] | number[];\n  itemSelected: T;\n  idSelected: string | number;\n  entitiesSelected: Dictionary<T>;\n}\n\nexport interface EntityCrudBaseSelectors<T, V> {\n\n  /**\n   * - used to select last criteria\n   * @param (state: V) => ICriteria\n   */\n  selectLastCriteria: (state: V) => ICriteria;\n  /**\n   * - used to select an error\n   * @param (state: V) => string\n   */\n  selectError: (state: V) => string;\n  /**\n   * - returns true if there are calls in progress\n   * @@param (state: V) => boolean\n   */\n  selectIsLoading: (state: V) => boolean;\n  /**\n   * - returns true if all calls are completed\n   * @@param (state: V) => boolean\n   */\n  selectIsLoaded: (state: V) => boolean;\n  /**\n   * - used to select response variable contained in the formula\n   * @param (state: V) => OptResponse<T>[]\n   */\n  selectResponses: (state: V) => OptResponse<T>[];\n\n}\n\nexport interface EntitySingleCrudSelectors<T, V> extends EntityCrudBaseSelectors<T, V> {\n  selectItem: (state: V) => T;\n}\n\nexport interface EntityCrudSelectors<T, V> extends EntityCrudBaseSelectors<T, V>, EntitySelectors<T, V> {\n  /**\n   * - used to select selected id\n   * - populated with action \"...SelectedItem({item})\",\n   * @param (state: V) => string | number\n   */\n  selectIdSelected: (state: V) => string | number;\n  /**\n   * - used to select selected ids\n   * - populated with action \"...SelectedItems({item})\",\n   * @param (state: V) => string[] | number[]\n   */\n  selectIdsSelected: (state: V) => string[] | number[];\n  /**\n   * - used to select selectedItem\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => T\n   */\n  selectItemSelected: (state: V) => T;\n  /**\n   * - used to select selected item\n   * - populated with action \"...SelectedItems({item:{id:string ...}})\",\n   * - same instance of the store (state.entities)\n   * - the selector is created with:\n   *    - selectIdSelected + selectEntities,\n   * @param (state: V) => T\n   */\n  selectItemSelectedOrigin: (state: V) => T;\n  /**\n   * - used to select a group of selected items\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => T[]\n   */\n  selectItemsSelected: (state: V) => T[];\n\n  /**\n   * - used to select a group of selected entities\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => Dictionary<T>\n   */\n  selectEntitiesSelected: (state: V) => Dictionary<T>;\n  /**\n   * - used to select a group of selected items\n   * - populated with action \"...SelectedItems({item})\",\n   * - same instance of the store (state.entities)\n   *    - selectIdsSelected + selectEntities,\n   * @param (state: V) => T[]\n   */\n  selectItemsSelectedOrigin: (state: V) => T[];\n  /**\n   * - used to select filters\n   * @param (state: V) => {[s: string]: FilterMetadata;}\n   */\n  selectFilters: (state: V) => { [s: string]: FilterMetadata; };\n  /**\n   * - used to select filtered items\n   * @param MemoizedSelector<V, T[]>\n   */\n  selectFilteredItems: MemoizedSelector<V, T[]>;\n\n}\n\n\nexport interface EntityCrudBaseState<T> {\n  error: string;\n  isLoading: boolean;\n  isLoaded: boolean;\n  lastCriteria: ICriteria;\n  // ogni entità registra l'azione scatenata e la risposta dal server.\n  responses: OptResponse<T>[];\n}\n\nexport interface EntitySingleCrudState<T> extends EntityCrudBaseState<T> {\n  item: T\n}\n\nexport interface EntityCrudState<T> extends EntityCrudBaseState<T>, EntityState<T> {\n  filters: { [s: string]: FilterMetadata; };\n  itemSelected: T;\n  idSelected: string | number;\n\n  entitiesSelected: Dictionary<T>;\n\n  idsSelected: string[] | number[];\n}\n\nexport interface EntityCrudAdapter<T> extends EntityAdapter<T> {\n  getInitialCrudState(): EntityCrudState<T>;\n\n  getInitialCrudState<S extends object>(state: S): EntityCrudState<T> & S;\n\n  getCrudSelectors<V>(selectState: (state: V) => EntityCrudState<T>): EntityCrudSelectors<T, V>;\n\n  createCrudActions(name: string): Actions<T>;\n\n  // todo modificare la firma del metodo, tipizzare Actions<any>\n  createCrudReducer<S>(initialState: S, actions: Actions<any>);\n}\n\ninterface PropsSearchSuccess<T> {\n  items: T;\n  request: ICriteria;\n}\n\nexport interface SingularActions<T> {\n  // azione dispacciata dall'effect se:\n  // OptRequestBase.dispatchResponse === true\n  // OptEffect.dispatchResponse === true\n  Response: ActionCreator<string, (props: OptResponse<T | T[]>) => OptResponse<T | T[]> & TypedAction<string>>;\n  ResetResponses: ActionCreator<string, () => { type: string; }>;\n\n  /**\n   *  - action used to execute a request to select an item\n   * @example store.dispatch(actions.SelectRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  SelectRequest: ActionCreator<string, (props: ICriteria) => ICriteria & TypedAction<string>>;\n  SelectFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  SelectSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n\n  /**\n   *  - action used to execute a request to modify an item\n   * @example store.dispatch(actions.EditRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  EditRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  EditFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  EditSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a store reset\n   * @example store.dispatch(actions.Reset());\n   * @param type: string\n   */\n  Reset: ActionCreator<string, () => { type: string; }>;\n\n  /**\n   * - action used to modify an item on the store\n   * @example store.dispatch(actions.Edit(payload));\n   * @param item: T\n   */\n  Edit: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n}\n\nexport interface Actions<T> extends SingularActions<T> {\n\n  /**\n   * - action used to execute asynchronous researches\n   * @example StoreActions.SearchRequest({queryParams: {}})\n   * - mode?: 'REFRESH': se viene passato il valore REFRESH, il dato presente nello store viene cancellato prima di eseguire la chiamata,\n   *        altrimenti il dato verrà sostituito al result della chiamata\n   * @param mode?: 'REFRESH' | 'upsertMany' | 'addAll'\n   * @param queryParams?: any\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   * @param type: string\n   *\n   */\n  SearchRequest: ActionCreator<string, (props: ICriteria) => ICriteria & TypedAction<string>>;\n  SearchFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  SearchSuccess: ActionCreator<string, (props: { items: T[], request: ICriteria }) => { items: T[], request: ICriteria } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to remove an item\n   * @example const toState: State = featureReducer(state, actions.DeleteRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  DeleteRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  DeleteFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  DeleteSuccess: ActionCreator<string, (props: { id: string, request: OptRequest }) => { id: string, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to remove more items\n   * @example this.store$.dispatch(<%= clazz %>StoreActions.DeleteManyRequest({items}));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  DeleteManyRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  DeleteManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  DeleteManySuccess: ActionCreator<string, (props: { ids: string[], request: OptRequest }) => { ids: string[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to create a new item\n   * @example  store.dispatch(actions.CreateRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  CreateRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  CreateFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  CreateSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to create more new items\n   * @example store.dispatch(actions.CreateManyRequest(payload));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  CreateManyRequest: ActionCreator<string, (props: OptRequest<T[] | T>) => OptRequest<T[] | T> & TypedAction<string>>;\n  CreateManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  CreateManySuccess: ActionCreator<string, (props: { items: T[], request: OptRequest }) => { items: T[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   *  - action used to execute a request to modify more items\n   * @example store.dispatch(actions.EditManyRequest(payload));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  EditManyRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  EditManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  EditManySuccess: ActionCreator<string, (props: { items: T[], request: OptRequest }) => { items: T[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to apply some filters on data\n   * @example store.dispatch(actions.Filters(payload));\n   * @param filters: { [s: string]: FilterMetadata;}\n   */\n  Filters: ActionCreator<string, (props: { filters: { [s: string]: FilterMetadata; }; }) => { filters: { [s: string]: FilterMetadata; }; } & TypedAction<string>>;\n\n  // selezione locale di + elementi\n  /**\n   * - action used to identify a group of items to select\n   * @example store.dispatch(actions.SelectItems(payload));\n   * @param items: T[]\n   */\n  SelectItems: ActionCreator<string, (props: { items: T[]; }) => { items: T[]; } & TypedAction<string>>;\n  // TODO: doc\n  AddManySelected: ActionCreator<string, (props: { items: T[]; }) => { items: T[]; } & TypedAction<string>>;\n  // TODO: doc\n  RemoveManySelected: ActionCreator<string, (props: { ids: string[]; }) => { ids: string[]; } & TypedAction<string>>;\n  // TODO: doc\n  RemoveAllSelected: ActionCreator<string>;\n  /**\n   * - action used to identify a single item to select\n   * @example store.dispatch(actions.SelectItem(payload));\n   * @param item: T\n   */\n  SelectItem: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n\n  /**\n   * - action used to create an item on the store\n   * @example store.dispatch(actions.Create(payload));\n   * @param item: T\n   */\n  Create: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n\n  /**\n   * - action used to remove an item on the store\n   * @example const toState: State = featureReducer(expectState, actions.Delete(payload));\n   * @param id: string\n   */\n  Delete: ActionCreator<string, (props: { id: string; }) => { id: string; } & TypedAction<string>>;\n\n}\n"]}
17
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../projects/ngrx-entity-crud/src/lib/models.ts"],"names":[],"mappings":"AAwDA,MAAM,CAAN,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6BAAiB,CAAA;IACjB,6BAAiB,CAAA;IACjB,6BAAiB,CAAA;IACjB,yBAAa,CAAA;IACb,6BAAiB,CAAA;IACjB,2BAAe,CAAA;AACjB,CAAC,EAPW,QAAQ,KAAR,QAAQ,QAOnB;AAED,MAAM,CAAN,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,mCAAqB,CAAA;IACrB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;AACrB,CAAC,EALW,UAAU,KAAV,UAAU,QAKrB","sourcesContent":["import {EntityAdapter, EntityState} from '@ngrx/entity';\nimport {Action, ActionCreator, MemoizedSelector} from '@ngrx/store';\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/store/src/models, da errori nei progetti dove viene utilizzato.\nexport declare interface TypedAction<T extends string> extends Action {\n  readonly type: T;\n}\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport interface DictionaryNum<T> {\n  [id: number]: T | undefined;\n}\n\nexport declare abstract class Dictionary<T> implements DictionaryNum<T> {\n  [id: string]: T | undefined;\n}\n\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport type IdSelectorStr<T> = (model: T) => string;\nexport type IdSelectorNum<T> = (model: T) => number;\n// COPIATO DA @ngrx/store/src/models\n// se viene importato da @ngrx/entity/src/models, da errori nei progetti dove viene utilizzato.\nexport type IdSelector<T> = IdSelectorStr<T> | IdSelectorNum<T>;\n\n// per evitare l'importazione\n// import {Comparer, EntityAdapter, IdSelector} from '@ngrx/entity/src/models';\n// ho copiato i seguenti type\nexport declare type ComparerStr<T> = (a: T, b: T) => string;\nexport declare type Comparer<T> = (a: T, b: T) => number;\n\nexport interface EntitySelectors<T, V> {\n  /**\n   * - used to select a group of ids\n   * @param (state: V) => string[] | number[]\n   */\n  selectIds: (state: V) => string[] | number[];\n  /**\n   * - used to select a group of entities\n   * @param (state: V) => Dictionary<T>\n   */\n  selectEntities: (state: V) => Dictionary<T>;\n  /**\n   * - used to select all items\n   * @param (state: V) => T[]\n   */\n  selectAll: (state: V) => T[];\n  /**\n   * - used to select the sum of items\n   * @param (state: V) => number\n   */\n  selectTotal: (state: V) => number;\n}\n\nexport enum CrudEnum {\n  SEARCH = 'Search',\n  DELETE = 'Delete',\n  CREATE = 'Create',\n  EDIT = 'Edit',\n  SELECT = 'Select',\n  RESET = 'Reset',\n}\n\nexport enum ActionEnum {\n  RESPONSE = 'Response',\n  REQUEST = 'Request',\n  FAILURE = 'Failure',\n  SUCCESS = 'Success',\n}\n\nexport interface OptRequestBase {\n  /**\n   * is added to the service route,\n   * in some cases it is necessary to invoke a sub-route.\n   * if the service was \"user\" and the sub-route \"user/accept\":\n   * path:[\"accept\"]\n   */\n  path?: any[];\n  /**\n   * Dispatched actions in case of error.\n   */\n  onFault?: Action[];\n  /**\n   * Dispatched actions in the event of a positive response\n   */\n  onResult?: Action[];\n\n  /**\n   * se true, al completamento della chiamata asincrona, verrà inviata un'azione di tipo Response,\n   * contenente le informazioni sulla chiamata e la risposta.\n   * In questo modo sarà possibile analizzare l'andamento\n   */\n  dispatchResponse?: boolean;\n  \n  /**\n  * used to override the root of the service \n  */\n  basePath?: string;\n}\n\n/**\n * - criteria: ICriteria: criteria di ricerca\n */\nexport interface ICriteria<QP = any> extends OptRequestBase {\n  /**\n   *\n   * \"REFRESH\" the store will be deleted before making the remote call, all the elements will be added to the call result.\n   *\n   */\n  mode?: 'REFRESH' | 'upsertMany' | 'upsertMany-updateMany-selected' | 'addAll';\n\n  queryParams?: QP;\n}\n\nexport interface OptRequest<T = any> extends OptRequestBase {\n  mutationParams: T;\n  /**\n   * options optional\n   */\n  options?: any;\n}\n\nexport interface OptResponse<T> {\n  actionType: string;\n  response: Response<T>;\n  request: ICriteria | OptRequest;\n}\n\nexport interface OptEffect {\n  /**\n   * per ogni stringa presente nell'attributo, verrà spedita una notifica Response.\n   * in questo modo, chi invia la notifica potrà poi filtrare i dati in base alla chiave inviata.\n   */\n  dispatchResponse?: boolean;\n}\n\nexport interface Response<T> {\n  data: T | any;\n  hasError: boolean;\n  message: string;\n}\n\nexport interface FilterMetadata {\n  value?: any;\n  matchMode?: string;\n  renderFunction?: (value: any) => string;\n}\n\nexport interface CrudBaseState<T> {\n  error: string;\n  isLoading: boolean;\n  isLoaded: boolean;\n  lastCriteria: ICriteria;\n  responses: OptResponse<T>[];\n}\n\nexport interface SingleCrudState<T> extends CrudBaseState<T> {\n  item: T\n}\n\nexport interface CrudState<T> extends CrudBaseState<T>, EntityState<T> {\n  filters: { [s: string]: FilterMetadata; };\n  idsSelected: string[] | number[];\n  itemSelected: T;\n  idSelected: string | number;\n  entitiesSelected: Dictionary<T>;\n}\n\nexport interface EntityCrudBaseSelectors<T, V> {\n\n  /**\n   * - used to select last criteria\n   * @param (state: V) => ICriteria\n   */\n  selectLastCriteria: (state: V) => ICriteria;\n  /**\n   * - used to select an error\n   * @param (state: V) => string\n   */\n  selectError: (state: V) => string;\n  /**\n   * - returns true if there are calls in progress\n   * @@param (state: V) => boolean\n   */\n  selectIsLoading: (state: V) => boolean;\n  /**\n   * - returns true if all calls are completed\n   * @@param (state: V) => boolean\n   */\n  selectIsLoaded: (state: V) => boolean;\n  /**\n   * - used to select response variable contained in the formula\n   * @param (state: V) => OptResponse<T>[]\n   */\n  selectResponses: (state: V) => OptResponse<T>[];\n\n}\n\nexport interface EntitySingleCrudSelectors<T, V> extends EntityCrudBaseSelectors<T, V> {\n  selectItem: (state: V) => T;\n}\n\nexport interface EntityCrudSelectors<T, V> extends EntityCrudBaseSelectors<T, V>, EntitySelectors<T, V> {\n  /**\n   * - used to select selected id\n   * - populated with action \"...SelectedItem({item})\",\n   * @param (state: V) => string | number\n   */\n  selectIdSelected: (state: V) => string | number;\n  /**\n   * - used to select selected ids\n   * - populated with action \"...SelectedItems({item})\",\n   * @param (state: V) => string[] | number[]\n   */\n  selectIdsSelected: (state: V) => string[] | number[];\n  /**\n   * - used to select selectedItem\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => T\n   */\n  selectItemSelected: (state: V) => T;\n  /**\n   * - used to select selected item\n   * - populated with action \"...SelectedItems({item:{id:string ...}})\",\n   * - same instance of the store (state.entities)\n   * - the selector is created with:\n   *    - selectIdSelected + selectEntities,\n   * @param (state: V) => T\n   */\n  selectItemSelectedOrigin: (state: V) => T;\n  /**\n   * - used to select a group of selected items\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => T[]\n   */\n  selectItemsSelected: (state: V) => T[];\n\n  /**\n   * - used to select a group of selected entities\n   * - populated with action \"...SelectedItems({item})\",\n   * - local clone, does not match the instance in the store\n   * @param (state: V) => Dictionary<T>\n   */\n  selectEntitiesSelected: (state: V) => Dictionary<T>;\n  /**\n   * - used to select a group of selected items\n   * - populated with action \"...SelectedItems({item})\",\n   * - same instance of the store (state.entities)\n   *    - selectIdsSelected + selectEntities,\n   * @param (state: V) => T[]\n   */\n  selectItemsSelectedOrigin: (state: V) => T[];\n  /**\n   * - used to select filters\n   * @param (state: V) => {[s: string]: FilterMetadata;}\n   */\n  selectFilters: (state: V) => { [s: string]: FilterMetadata; };\n  /**\n   * - used to select filtered items\n   * @param MemoizedSelector<V, T[]>\n   */\n  selectFilteredItems: MemoizedSelector<V, T[]>;\n\n}\n\n\nexport interface EntityCrudBaseState<T> {\n  error: string;\n  isLoading: boolean;\n  isLoaded: boolean;\n  lastCriteria: ICriteria;\n  // ogni entità registra l'azione scatenata e la risposta dal server.\n  responses: OptResponse<T>[];\n}\n\nexport interface EntitySingleCrudState<T> extends EntityCrudBaseState<T> {\n  item: T\n}\n\nexport interface EntityCrudState<T> extends EntityCrudBaseState<T>, EntityState<T> {\n  filters: { [s: string]: FilterMetadata; };\n  itemSelected: T;\n  idSelected: string | number;\n\n  entitiesSelected: Dictionary<T>;\n\n  idsSelected: string[] | number[];\n}\n\nexport interface EntityCrudAdapter<T> extends EntityAdapter<T> {\n  getInitialCrudState(): EntityCrudState<T>;\n\n  getInitialCrudState<S extends object>(state: S): EntityCrudState<T> & S;\n\n  getCrudSelectors<V>(selectState: (state: V) => EntityCrudState<T>): EntityCrudSelectors<T, V>;\n\n  createCrudActions(name: string): Actions<T>;\n\n  // todo modificare la firma del metodo, tipizzare Actions<any>\n  createCrudReducer<S>(initialState: S, actions: Actions<any>);\n}\n\ninterface PropsSearchSuccess<T> {\n  items: T;\n  request: ICriteria;\n}\n\nexport interface SingularActions<T> {\n  // azione dispacciata dall'effect se:\n  // OptRequestBase.dispatchResponse === true\n  // OptEffect.dispatchResponse === true\n  Response: ActionCreator<string, (props: OptResponse<T | T[]>) => OptResponse<T | T[]> & TypedAction<string>>;\n  ResetResponses: ActionCreator<string, () => { type: string; }>;\n\n  /**\n   *  - action used to execute a request to select an item\n   * @example store.dispatch(actions.SelectRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  SelectRequest: ActionCreator<string, (props: ICriteria) => ICriteria & TypedAction<string>>;\n  SelectFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  SelectSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n\n  /**\n   *  - action used to execute a request to modify an item\n   * @example store.dispatch(actions.EditRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  EditRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  EditFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  EditSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a store reset\n   * @example store.dispatch(actions.Reset());\n   * @param type: string\n   */\n  Reset: ActionCreator<string, () => { type: string; }>;\n\n  /**\n   * - action used to modify an item on the store\n   * @example store.dispatch(actions.Edit(payload));\n   * @param item: T\n   */\n  Edit: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n}\n\nexport interface Actions<T> extends SingularActions<T> {\n\n  /**\n   * - action used to execute asynchronous researches\n   * @example StoreActions.SearchRequest({queryParams: {}})\n   * - mode?: 'REFRESH': se viene passato il valore REFRESH, il dato presente nello store viene cancellato prima di eseguire la chiamata,\n   *        altrimenti il dato verrà sostituito al result della chiamata\n   * @param mode?: 'REFRESH' | 'upsertMany' | 'addAll'\n   * @param queryParams?: any\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   * @param type: string\n   *\n   */\n  SearchRequest: ActionCreator<string, (props: ICriteria) => ICriteria & TypedAction<string>>;\n  SearchFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  SearchSuccess: ActionCreator<string, (props: { items: T[], request: ICriteria }) => { items: T[], request: ICriteria } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to remove an item\n   * @example const toState: State = featureReducer(state, actions.DeleteRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  DeleteRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  DeleteFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  DeleteSuccess: ActionCreator<string, (props: { id: string, request: OptRequest }) => { id: string, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to remove more items\n   * @example this.store$.dispatch(<%= clazz %>StoreActions.DeleteManyRequest({items}));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  DeleteManyRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  DeleteManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  DeleteManySuccess: ActionCreator<string, (props: { ids: string[], request: OptRequest }) => { ids: string[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to create a new item\n   * @example  store.dispatch(actions.CreateRequest(payload));\n   * @param item: T\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  CreateRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  CreateFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  CreateSuccess: ActionCreator<string, (props: { item: T, request: OptRequest }) => { item: T, request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to execute a request to create more new items\n   * @example store.dispatch(actions.CreateManyRequest(payload));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  CreateManyRequest: ActionCreator<string, (props: OptRequest<T[] | T>) => OptRequest<T[] | T> & TypedAction<string>>;\n  CreateManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  CreateManySuccess: ActionCreator<string, (props: { items: T[], request: OptRequest }) => { items: T[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   *  - action used to execute a request to modify more items\n   * @example store.dispatch(actions.EditManyRequest(payload));\n   * @param items: T[]\n   * @param path?: any[]\n   * @param onFault?: Action[]\n   * @param onResult?: Action[]\n   * @param dispatchResponse?: boolean\n   */\n  EditManyRequest: ActionCreator<string, (props: OptRequest) => OptRequest & TypedAction<string>>;\n  EditManyFailure: ActionCreator<string, (props: { error: string; }) => { error: string; } & TypedAction<string>>;\n  EditManySuccess: ActionCreator<string, (props: { items: T[], request: OptRequest }) => { items: T[], request: OptRequest } & TypedAction<string>>;\n\n  /**\n   * - action used to apply some filters on data\n   * @example store.dispatch(actions.Filters(payload));\n   * @param filters: { [s: string]: FilterMetadata;}\n   */\n  Filters: ActionCreator<string, (props: { filters: { [s: string]: FilterMetadata; }; }) => { filters: { [s: string]: FilterMetadata; }; } & TypedAction<string>>;\n\n  // selezione locale di + elementi\n  /**\n   * - action used to identify a group of items to select\n   * @example store.dispatch(actions.SelectItems(payload));\n   * @param items: T[]\n   */\n  SelectItems: ActionCreator<string, (props: { items: T[]; }) => { items: T[]; } & TypedAction<string>>;\n  // TODO: doc\n  AddManySelected: ActionCreator<string, (props: { items: T[]; }) => { items: T[]; } & TypedAction<string>>;\n  // TODO: doc\n  RemoveManySelected: ActionCreator<string, (props: { ids: string[]; }) => { ids: string[]; } & TypedAction<string>>;\n  // TODO: doc\n  RemoveAllSelected: ActionCreator<string>;\n  /**\n   * - action used to identify a single item to select\n   * @example store.dispatch(actions.SelectItem(payload));\n   * @param item: T\n   */\n  SelectItem: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n\n  /**\n   * - action used to create an item on the store\n   * @example store.dispatch(actions.Create(payload));\n   * @param item: T\n   */\n  Create: ActionCreator<string, (props: { item: T; }) => { item: T; } & TypedAction<string>>;\n\n  /**\n   * - action used to remove an item on the store\n   * @example const toState: State = featureReducer(expectState, actions.Delete(payload));\n   * @param id: string\n   */\n  Delete: ActionCreator<string, (props: { id: string; }) => { id: string; } & TypedAction<string>>;\n\n}\n"]}