@uxland/primary-shell 3.5.4 → 4.0.0

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/reducer.ts

@@ -0,0 +1,41 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { SetCustomFilterValuePayload } from "./request";
+
+export function setCustomFilterValueReducer(
+  state,
+  action: PayloadAction<SetCustomFilterValuePayload>,
+) {
+  state.filters = state.filters.map((f) => {
+    if (f.id === action.payload.filterGroupId) {
+      return {
+        ...f,
+        filters: f.filters.map((ff) =>
+          ff.id === action.payload.filterId
+            ? ff.singleOption
+              ? setSingleOptionFilterValue(ff, action.payload.enabled)
+              : setMultipleOptionsFilterValue(ff, action.payload)
+            : ff,
+        ),
+      };
+    }
+    return f;
+  });
+}
+
+const setMultipleOptionsFilterValue = (filter, payload: SetCustomFilterValuePayload) => {
+  const { optionId, enabled } = payload;
+  return {
+    ...filter,
+    enabledValues: enabled
+      ? [...(filter.enabledValues || []), optionId]
+      : filter.enabledValues.filter((id) => id !== optionId),
+  };
+};
+
+const setSingleOptionFilterValue = (filter, value: boolean) => {
+  return {
+    ...filter,
+    enabled: value,
+    enabledValues: value ? [true] : [],
+  };
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/request.ts

@@ -0,0 +1,10 @@
+export interface SetCustomFilterValuePayload {
+  filterGroupId: string;
+  filterId: string;
+  optionId: string;
+  enabled: boolean;
+}
+
+export class SetCustomFilterValue {
+  constructor(public payload: SetCustomFilterValuePayload) {}
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/index.ts

@@ -0,0 +1 @@
+export * from "./model";

package/src/internal-plugins/activity-history/activity-history-item/filter/model.ts

@@ -1,20 +1,59 @@
 import { IActivityHistoryItem } from "../domain/model";
 import { Spec } from "../domain/specs/spec";
-import { ActivityHistoryFilterOperation, ActivityHistoryFilterType } from "./constants";
 
 type Constructor<T> = new (...args: any[]) => T;
 
-export interface IActivityHistoryFilterGroup {
+export enum ActivityHistoryFilterType {
+  Switch = "switch",
+  Checkbox = "checkbox",
+}
+
+export enum ActivityHistoryFilterOperation {
+  And = "and",
+  Or = "or",
+}
+
+export interface IActivityHistoryCommonFilterGroup {
   id: string;
   title: string;
-  filters: IActivityHistoryFilter[];
+  filters: IActivityHistoryCommonFilter[];
 }
 
-export interface IActivityHistoryFilter {
+export interface IActivityHistoryCommonFilter {
   id: string;
   title: string;
   spec: Constructor<Spec<IActivityHistoryItem>>;
   enabled: boolean;
   type: ActivityHistoryFilterType;
-  operation: ActivityHistoryFilterOperation;
 }
+
+export interface IActivityHistoryCustomFilterGroup {
+  id: string;
+  title: string;
+  enabled: boolean;
+  sort: string;
+  filters: IActivityHistoryCustomFilter[];
+}
+
+export type IActivityHistoryFilterGroup =
+  | IActivityHistoryCommonFilterGroup
+  | IActivityHistoryCustomFilterGroup;
+
+export interface IActivityHistoryCustomFilter {
+  id: string;
+  title: string;
+  propPathValue: string[];
+  propsPathDescription: string[];
+  enabled: boolean;
+  type: ActivityHistoryFilterType;
+  singleOption?: boolean;
+  options?: {
+    id: string;
+    title: string;
+  }[];
+  enabledValues?: string[];
+}
+
+export const isCommonFilterGroup = (group: IActivityHistoryFilterGroup) => group.id === "common";
+export const isNotCommonFilterGroup = (group: IActivityHistoryFilterGroup) =>
+  !isCommonFilterGroup(group);

package/src/internal-plugins/activity-history/activity-history-item/filter/selectors.ts

@@ -1,28 +1,4 @@
-import { createSelector } from "@reduxjs/toolkit";
 import { RootState } from "../../infrastructure/state/store";
-import { TrueSpec } from "../domain/specs/true-spec";
-import { IActivityHistoryFilter } from "./model";
 
 export const activityHistoryFiltersSelector = (state: RootState) =>
   state.activityHistoryFilters.filters;
-
-export const activityHistoryCommonFiltersSelector = createSelector(
-  activityHistoryFiltersSelector,
-  (filters) => filters.find((f) => f.id === "common")?.filters,
-);
-export const isEnabledCommonFilterSelector = (filterId: string) =>
-  createSelector(
-    activityHistoryCommonFiltersSelector,
-    (filterSpecs) => filterSpecs?.find((s) => s.id === filterId)?.enabled,
-  );
-
-export const commonSpecSelector = createSelector(
-  activityHistoryCommonFiltersSelector,
-  (commonFilters: IActivityHistoryFilter[]) => {
-    const enabledCommonFilters = commonFilters.filter((f) => f.enabled);
-    const finalCommonSpec = enabledCommonFilters.reduce((acc, filter) => {
-      return acc.and(new filter.spec());
-    }, new TrueSpec());
-    return finalCommonSpec;
-  },
-);

package/src/internal-plugins/activity-history/activity-history-item/filter/slice.ts

@@ -1,27 +1,23 @@
 import { createSlice } from "@reduxjs/toolkit";
-import { commonFilters } from "./common-filters";
 import { setSearchStringReducer } from "../search/reducer";
+import { commonFilters } from "./common-filters/common-filters";
+import { setCommonFilterValueReducer } from "./common-filters/set-common-filter/reducer";
+import { addCustomFiltersReducer } from "./custom-filters/add-custom-filters/reducer";
+import { setCustomFilterGroupValueReducer } from "./custom-filters/set-custom-filter-group/reducer";
+import { setCustomFilterValueReducer } from "./custom-filters/set-custom-filter-value/reducer";
+import { IActivityHistoryFilterGroup } from "./model";
 
 export const activityHistoryFiltersSlice = createSlice({
   name: "activity-history-filters",
   initialState: {
     searchString: "",
-    filters: [...commonFilters],
+    filters: [...commonFilters] as IActivityHistoryFilterGroup[],
   },
   reducers: {
     setSearchString: setSearchStringReducer,
-    setCommonFilterValue(state, action) {
-      state.filters = state.filters.map((f) => {
-        if (f.id === "common") {
-          return {
-            ...f,
-            filters: f.filters.map((ff) =>
-              ff.id === action.payload.id ? { ...ff, enabled: action.payload.enabled } : ff,
-            ),
-          };
-        }
-        return f;
-      });
-    },
+    setCommonFilterValue: setCommonFilterValueReducer,
+    addCustomFilters: addCustomFiltersReducer,
+    setCustomFilterGroupValue: setCustomFilterGroupValueReducer,
+    setCustomFilterValue: setCustomFilterValueReducer,
   },
 });

package/src/internal-plugins/activity-history/activity-history-item/index.ts

@@ -0,0 +1,5 @@
+export * from "./filter";
+export { addAsyncHistoryItemsCommand } from "./add/add-async-history-items/request";
+export { addHistoryItemsCommand } from "./add/add-history-items/request";
+export { addHistoryItemCommand } from "./add/add-history-item/request";
+export { updateHistoryItemCommand } from "./update/request";

package/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/activity-history-main.ts

@@ -8,7 +8,7 @@ import { lazyInject } from "../../../../infrastructure/ioc/container";
 import { TYPES } from "../../../../infrastructure/ioc/types";
 import { connectedProperty } from "../../../../infrastructure/state/connected-property";
 import { SearchActivityHistoryItems } from "../../../search/request";
-import { activityHistoryCollectionsSelector } from "../../selectors";
+import { activityHistoryCollectionsSelector } from "../../../selectors";
 import { ActivityHistoryTimeline } from "../timeline/activity-history-timeline";
 import styles from "./styles.css?inline";
 import { template } from "./template";

package/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/template.ts

@@ -19,9 +19,9 @@ export const template = (props: ActivityHistoryMain) =>
             </div>
             
             <div class="header__right">
-                <dss-icon-button @click=${() => props._maximize()} size="md" variant="primary" icon="arrow_forward" label="Botó maximitzar"></dss-icon-button>
+                <dss-icon-button @click=${() => props._maximize()} size="md" variant="primary" icon="arrow_forward" label=${translate("actions.maximizeButton")}></dss-icon-button>
                 <div>|</div>
-                <dss-icon-button size="md" variant="primary" icon="more_vert" label="Botó menu"></dss-icon-button>
+                <dss-icon-button size="md" variant="primary" icon="more_vert" label=${translate("actions.menuButton")}></dss-icon-button>
                 <dss-action-menu position="bottom-start">
                     <dss-action-menu-item lefticon="view_timeline" label=${translate("actions.cronogram")}></dss-action-menu-item>
                     <dss-action-menu-item lefticon="file_download" label=${translate("actions.exportPdf")} @click=${() => props.api.broker.send(new ExportPdf())}></dss-action-menu-item>
@@ -31,7 +31,7 @@ export const template = (props: ActivityHistoryMain) =>
         </div>`
   } 
         <div class="wrapper" ?maximized=${props.maximized}>
-          <activity-history-filters></activity-history-filters>
+          <activity-history-filters .wrapperMaximized=${props.maximized}></activity-history-filters>
           <div class="content">
             ${when(props.searchQuery.length > 1, () => html`<activity-history-search-header searchQuery="${props.searchQuery}"></activity-history-search-header>`)}
             <activity-history-busy></activity-history-busy>

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/activity-history-timeline.ts

@@ -7,7 +7,7 @@ import {
   isAnyCollectionLoadingWithoutAnyLoaded,
   isSomeCollectionLoadedAndOtherLoading,
 } from "../../handle-busy/selectors";
-import { activityHistoryGroupedItems } from "../../selectors";
+import { activityHistoryGroupedItems } from "../../../selectors";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 

package/src/internal-plugins/activity-history/activity-history-item/list/handle-error/reducers.ts

@@ -1,6 +1,11 @@
-export function addErrorHistoryItemReducer(state, action) {
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function addErrorHistoryItemReducer(
+  state,
+  action: PayloadAction<{ id: string; message: string }>,
+) {
   state.error.push(action.payload);
 }
-export function removeErrorHistoryItemReducer(state, action) {
+export function removeErrorHistoryItemReducer(state, action: PayloadAction<string>) {
   state.error = state.error.filter((i) => i !== action.payload);
 }

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/styles.css

@@ -2,7 +2,7 @@
   padding-inline: 16px;
   padding-top: 12px;
   padding-bottom: 12px;
-  gap: var(--dds-spacing-xs);
+  gap: var(--dss-spacing-xs);
   border-width: 0px 0px 1px 0px;
   border-style: solid;
   border-color: #D8D8D8;

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-results/styles.css

@@ -2,7 +2,7 @@
   padding-inline: 16px;
   padding-top: 12px;
   padding-bottom: 12px;
-  gap: var(--dds-spacing-xs);
+  gap: var(--dss-spacing-xs);
   border-width: 0px 0px 1px 0px;
   border-style: solid;
   border-color: #D8D8D8;

package/src/internal-plugins/activity-history/activity-history-item/selectors.ts

@@ -0,0 +1,107 @@
+import { createSelector } from "@reduxjs/toolkit";
+import { RootState } from "../infrastructure/state/store";
+import { getUniqueObjects } from "../utils/get-unique-values-by-prop-path";
+import {
+  IActivityHistoryItem,
+  IActivityHistoryItemCollection,
+  TSearchActivityHistoryItemPredicate,
+} from "./domain/model";
+import { CommonFilterSpec } from "./domain/specs/common-filter-spec";
+import { CustomFilterSpec } from "./domain/specs/custom-filter-spec";
+import { SearchStringSpec } from "./domain/specs/search-string-spec";
+import { ComposedTypeSpec } from "./domain/specs/type-spec";
+import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup } from "./filter";
+import { activityHistoryCommonFiltersSelector } from "./filter/common-filters/selectors";
+import { activityHistoryCustomFilterGroupsSelector } from "./filter/custom-filters/selectors";
+import { groupActivityHistoryItems } from "./list/group-history-items/group-history-items";
+import { sortGroupsByMostRecentDate } from "./list/sort-history-items-by-date/sort-history-items-by-date";
+import { activityHistorySearchStringSelector } from "./search/selectors";
+
+export const activityHistoryCollectionsSelector = (state: RootState) =>
+  state.activityHistoryCollections.collections;
+
+const mapItemsWithMetadata = (
+  items: IActivityHistoryItem[],
+  componentFactory: any,
+  type: string,
+  searchPredicate: TSearchActivityHistoryItemPredicate,
+) => {
+  return items.map(
+    (item) =>
+      ({
+        ...item,
+        searchPredicate,
+        componentFactory,
+        type,
+      }) as IActivityHistoryItem,
+  );
+};
+
+export const activityHistoryMappedItems = createSelector(
+  activityHistoryCollectionsSelector,
+  (collections: Record<string, IActivityHistoryItemCollection>) => {
+    return Object.values(collections).flatMap((collection: IActivityHistoryItemCollection) => {
+      return mapItemsWithMetadata(
+        collection.items,
+        collection.componentFactory,
+        collection.id,
+        collection.searchPredicate,
+      );
+    });
+  },
+);
+
+export const customFilterGroupsWithOptionsSelector = createSelector(
+  activityHistoryCustomFilterGroupsSelector,
+  activityHistoryCollectionsSelector,
+  (
+    filterGroups: IActivityHistoryCustomFilterGroup[],
+    collections: Record<string, IActivityHistoryItemCollection>,
+  ) => {
+    const result = filterGroups.map((filterGroup: IActivityHistoryCustomFilterGroup) => {
+      const collection = collections[filterGroup.id] as IActivityHistoryItemCollection;
+      return {
+        ...filterGroup,
+        filters: filterGroup.filters.map((f) => {
+          return {
+            ...f,
+            options:
+              (!f.singleOption
+                ? getUniqueObjects<IActivityHistoryItem>(
+                    collection.items,
+                    f.propPathValue,
+                    f.propsPathDescription,
+                  )
+                : []) || [],
+          };
+        }),
+      };
+    });
+    return result;
+  },
+);
+
+export const activityHistoryGroupedItems = createSelector(
+  activityHistoryMappedItems,
+  activityHistorySearchStringSelector,
+  activityHistoryCommonFiltersSelector,
+  activityHistoryCustomFilterGroupsSelector,
+  (
+    items: IActivityHistoryItem[],
+    searchString: string,
+    commonFilters: IActivityHistoryCommonFilter[],
+    customFilters: IActivityHistoryCustomFilterGroup[],
+  ) => {
+    const filteredItems = items.filter((item: IActivityHistoryItem) =>
+      new SearchStringSpec(searchString, item.searchPredicate)
+        .and(new CommonFilterSpec(commonFilters))
+        .and(new ComposedTypeSpec(customFilters))
+        .and(new CustomFilterSpec(customFilters))
+        .isSatisfiedBy(item),
+    );
+
+    const groupedItems = groupActivityHistoryItems(filteredItems);
+    const sortedByMostRecentDate = sortGroupsByMostRecentDate(groupedItems);
+    return sortedByMostRecentDate;
+  },
+);

package/src/internal-plugins/activity-history/activity-history-item/update/bootstrapper.ts

@@ -1,12 +1,12 @@
 import { BrokerExtensions } from "@primaria/plugins-core";
 import { UpdateHistoryItemHandler } from "./handler";
-import { updateHistoryItemRequest } from "./request";
+import { updateHistoryItemCommand } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
 
 let request: BrokerDisposableHandler;
 
 export const bootstrapUpdateHistoryItem = (broker: BrokerExtensions) => {
-  request = broker.registerRequest(updateHistoryItemRequest, UpdateHistoryItemHandler);
+  request = broker.registerRequest(updateHistoryItemCommand, UpdateHistoryItemHandler);
 };
 
 export const teardownUpdateHistoryItem = () => {

package/src/internal-plugins/activity-history/activity-history-item/update/request.ts

@@ -5,4 +5,4 @@ export interface UpdateHistoryItemPayload {
   item: IActivityHistoryItem;
 }
 
-export const updateHistoryItemRequest = "update_history_item_request";
+export const updateHistoryItemCommand = "update_history_item_request";

package/src/internal-plugins/activity-history/index.ts

@@ -1 +1,2 @@
 export * from "./activity-history-item/domain/model";
+export * from "./activity-history-item";

package/src/internal-plugins/activity-history/localization.ts

@@ -46,12 +46,15 @@ export const locales = {
         noteLegend: "Llegenda notes",
         moreOptions: "Més opcions",
         entryLegend: "Llegenda entrades",
+        maximizeButton: "Botó maximitzar",
+        menuButton: "Botó menu",
       },
       modal: {
         selectExportOption: "Tria una opció d'exportació",
         allActivityHistory: "Tot l’històric d’activitat",
         onlyAppliedFilters: "Només amb filtres aplicats",
         selectDateRange: "En el cas que sigui necessari, selecciona un rang de dates",
+        helpText: "Sense seleccionar data, s'aplicarà la de la primera entrada. Sense seleccionar data de fi, s'aplicarà la de l'última entrada.",
         startDate: "Data Inici",
         endDate: "Data Fi",
         cancel: "Cancel·lar",

package/src/internal-plugins/activity-history/utils/get-unique-values-by-prop-path.ts

@@ -0,0 +1,19 @@
+export function getUniqueObjects<T>(
+  items: T[],
+  propPathId: string[],
+  propPathDescription: string[],
+): { id: string; description: string }[] {
+  return Array.from(
+    items
+      .map((item) => ({
+        id: propPathId.reduce((acc, key) => acc?.[key], item),
+        title: propPathDescription.reduce((acc, key) => acc?.[key], item),
+      }))
+      .filter((obj) => typeof obj.id === "string" && typeof obj.title === "string")
+      .reduce(
+        (map, obj) => map.set(obj.id, obj),
+        new Map<string, { id: string; description: string }>(),
+      )
+      .values(),
+  );
+}

package/src/locales.ts

@@ -39,6 +39,11 @@ export const locales = {
       clinicalMonitoring:{
         title: "Seguiment clínic",
       },
+      header: {
+        workCenter: "Centre treball",
+        role: "Rol",
+        speciality: "Àmbit treball",
+      }
     }
   },
 };

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/actions.d.ts

@@ -1 +0,0 @@
-export declare const setCommonFilterValue: import('@reduxjs/toolkit').ActionCreatorWithPayload<any, "activity-history-filters/setCommonFilterValue">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/common-filters.d.ts

@@ -1,3 +0,0 @@
-import { IActivityHistoryFilterGroup } from './model';
-
-export declare const commonFilters: IActivityHistoryFilterGroup[];

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/constants.d.ts

@@ -1,7 +0,0 @@
-export declare enum ActivityHistoryFilterType {
-    Switch = "switch"
-}
-export declare enum ActivityHistoryFilterOperation {
-    And = "and",
-    Or = "or"
-}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/selectors.d.ts

@@ -1,156 +0,0 @@
-import { RootState } from '../../infrastructure/state/store';
-import { IActivityHistoryItem, IActivityHistoryItemCollection } from '../domain/model';
-
-export declare const activityHistoryCollectionsSelector: (state: RootState) => Record<string, IActivityHistoryItemCollection>;
-export declare const activityHistoryMappedItems: ((state: {
-    activityHistoryCollections: {
-        busy: import('../..').IBusyHistoryItem[];
-        error: import('../..').IErrorHistoryItem[];
-        collections: Record<string, IActivityHistoryItemCollection>;
-    };
-    activityHistoryFilters: {
-        searchString: string;
-        filters: import('../filter/model').IActivityHistoryFilterGroup[];
-    };
-}) => IActivityHistoryItem[]) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => IActivityHistoryItem[];
-    dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-};
-export declare const activityHistoryGroupedItems: ((state: {
-    activityHistoryCollections: {
-        busy: import('../..').IBusyHistoryItem[];
-        error: import('../..').IErrorHistoryItem[];
-        collections: Record<string, IActivityHistoryItemCollection>;
-    };
-    activityHistoryFilters: {
-        searchString: string;
-        filters: import('../filter/model').IActivityHistoryFilterGroup[];
-    };
-}) => import('../..').IActivityHistoryGroup[]) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: import('../domain/specs/spec').ISpec<IActivityHistoryItem>) => import('../..').IActivityHistoryGroup[];
-    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: import('../domain/specs/spec').ISpec<IActivityHistoryItem>) => import('../..').IActivityHistoryGroup[]) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => import('../..').IActivityHistoryGroup[];
-    dependencies: [((state: {
-        activityHistoryCollections: {
-            busy: import('../..').IBusyHistoryItem[];
-            error: import('../..').IErrorHistoryItem[];
-            collections: Record<string, IActivityHistoryItemCollection>;
-        };
-        activityHistoryFilters: {
-            searchString: string;
-            filters: import('../filter/model').IActivityHistoryFilterGroup[];
-        };
-    }) => IActivityHistoryItem[]) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    } & {
-        resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
-        memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
-            clearCache: () => void;
-            resultsCount: () => number;
-            resetResultsCount: () => void;
-        };
-        lastResult: () => IActivityHistoryItem[];
-        dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
-        recomputations: () => number;
-        resetRecomputations: () => void;
-        dependencyRecomputations: () => number;
-        resetDependencyRecomputations: () => void;
-    } & {
-        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-    }, (state: RootState) => string, ((state: {
-        activityHistoryCollections: {
-            busy: import('../..').IBusyHistoryItem[];
-            error: import('../..').IErrorHistoryItem[];
-            collections: Record<string, IActivityHistoryItemCollection>;
-        };
-        activityHistoryFilters: {
-            searchString: string;
-            filters: import('../filter/model').IActivityHistoryFilterGroup[];
-        };
-    }) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    } & {
-        resultFunc: (resultFuncArgs_0: import('../filter/model').IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>;
-        memoizedResultFunc: ((resultFuncArgs_0: import('../filter/model').IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>) & {
-            clearCache: () => void;
-            resultsCount: () => number;
-            resetResultsCount: () => void;
-        };
-        lastResult: () => import('../domain/specs/spec').ISpec<IActivityHistoryItem>;
-        dependencies: [((state: {
-            activityHistoryCollections: {
-                busy: import('../..').IBusyHistoryItem[];
-                error: import('../..').IErrorHistoryItem[];
-                collections: Record<string, IActivityHistoryItemCollection>;
-            };
-            activityHistoryFilters: {
-                searchString: string;
-                filters: import('../filter/model').IActivityHistoryFilterGroup[];
-            };
-        }) => import('../filter/model').IActivityHistoryFilter[] | undefined) & {
-            clearCache: () => void;
-            resultsCount: () => number;
-            resetResultsCount: () => void;
-        } & {
-            resultFunc: (resultFuncArgs_0: import('../filter/model').IActivityHistoryFilterGroup[]) => import('../filter/model').IActivityHistoryFilter[] | undefined;
-            memoizedResultFunc: ((resultFuncArgs_0: import('../filter/model').IActivityHistoryFilterGroup[]) => import('../filter/model').IActivityHistoryFilter[] | undefined) & {
-                clearCache: () => void;
-                resultsCount: () => number;
-                resetResultsCount: () => void;
-            };
-            lastResult: () => import('../filter/model').IActivityHistoryFilter[] | undefined;
-            dependencies: [(state: RootState) => import('../filter/model').IActivityHistoryFilterGroup[]];
-            recomputations: () => number;
-            resetRecomputations: () => void;
-            dependencyRecomputations: () => number;
-            resetDependencyRecomputations: () => void;
-        } & {
-            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-        }];
-        recomputations: () => number;
-        resetRecomputations: () => void;
-        dependencyRecomputations: () => number;
-        resetDependencyRecomputations: () => void;
-    } & {
-        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-    }];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-};