@uxland/primary-shell 4.1.1 → 4.3.0

package/dist/primary/shell/src/UI/components/shell-header/shell-header.d.ts

@@ -10,6 +10,7 @@ export declare class ShellHeader extends ShellHeader_base {
     professional: IUserInfo;
     menuOpened: boolean;
     toggleMenu(): void;
+    logout(): void;
     connectedCallback(): void;
 }
 export {};

package/dist/primary/shell/src/api/api.d.ts

@@ -6,6 +6,7 @@ import { HttpClient } from './http-client/http-client';
 import { PrimariaInteractionManager } from './interaction-manager/interaction';
 import { TokenManager } from './token-manager/token-manager';
 import { EcapEventManager } from './ecap-event-manager/ecap-event-manager';
+import { PluginBusyManager } from './plugin-busy-manager/plugin-busy-manager';
 
 export interface PrimariaApi extends HarmonixApi {
     httpClient: HttpClient;
@@ -15,6 +16,7 @@ export interface PrimariaApi extends HarmonixApi {
     globalStateManager: PrimariaGlobalStateManager;
     tokenManager: TokenManager;
     ecapEventManager: EcapEventManager;
+    pluginBusyManager: PluginBusyManager;
 }
 export declare const PrimariaRegionHost: any;
 /**

package/dist/primary/shell/src/api/http-client/http-client.d.ts

@@ -1,8 +1,9 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { TokenManager } from '../token-manager/token-manager';
+import { PrimariaBroker } from '../broker/primaria-broker';
 
-export declare const createAxiosInstance: (tokenManager: TokenManager) => import('axios').AxiosInstance;
+export declare const createAxiosInstance: (tokenManager: TokenManager, broker: PrimariaBroker) => import('axios').AxiosInstance;
 export interface HttpClient {
     request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
 }
-export declare const createHttpClient: (tokenManager: TokenManager) => HttpClient;
+export declare const createHttpClient: (tokenManager: TokenManager, broker: PrimariaBroker) => HttpClient;

package/dist/primary/shell/src/api/plugin-busy-manager/plugin-busy-list/component.d.ts

@@ -0,0 +1,12 @@
+import { LitElement } from 'lit';
+import { PluginBusyTask } from '../plugin-busy-manager';
+
+declare const PluginBusyList_base: import('../../..').Constructor<import('../../..').ConfirmMixinBase> & typeof LitElement;
+export declare class PluginBusyList extends PluginBusyList_base {
+    static styles: import('lit').CSSResult;
+    render(): import('lit').TemplateResult<1>;
+    model: {
+        busyTasks: PluginBusyTask[];
+    };
+}
+export {};

package/dist/primary/shell/src/api/plugin-busy-manager/plugin-busy-list/template.d.ts

@@ -0,0 +1,3 @@
+import { PluginBusyList } from './component';
+
+export declare const template: (props: PluginBusyList) => import('lit').TemplateResult<1>;

package/dist/primary/shell/src/api/plugin-busy-manager/plugin-busy-manager.d.ts

@@ -0,0 +1,19 @@
+export interface PluginBusyTask {
+    taskId: string;
+    taskDescription: string;
+}
+export declare abstract class PluginBusyManager {
+    abstract addBusyPluginTask(busyTask: PluginBusyTask): void;
+    abstract removeBusyPluginTask(taskId: string): any;
+    abstract clearAllBusyPlugins(): void;
+    abstract isAnyPluginBusy(): boolean;
+    abstract getBusyPluginTasks(): PluginBusyTask[];
+}
+export declare class PluginBusyManagerImpl implements PluginBusyManager {
+    private busyPluginTasks;
+    addBusyPluginTask(busyTask: PluginBusyTask): void;
+    removeBusyPluginTask(taskId: string): any;
+    isAnyPluginBusy(): boolean;
+    clearAllBusyPlugins(): void;
+    getBusyPluginTasks(): PluginBusyTask[];
+}

package/dist/primary/shell/src/api/plugin-busy-manager/plugin-busy-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/api/token-manager/token-manager.d.ts

@@ -2,7 +2,7 @@ export interface TokenManager {
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }
-export declare class TokenManagerSimulator implements TokenManager {
+export declare class TokenManagerImpl implements TokenManager {
     getUrlParams: () => URLSearchParams;
     initToken: () => string;
     getToken: () => string;

package/dist/primary/shell/src/events.d.ts

@@ -2,4 +2,5 @@ export declare const shellEvents: {
     openClinicalMonitoringRequested: string;
     appCrashed: string;
     mainViewChanged: string;
+    refreshTokenFailed: string;
 };

package/dist/primary/shell/src/features/exit/bootstrapper.d.ts

@@ -0,0 +1,2 @@
+export declare const bootstrapExitShell: () => void;
+export declare const teardownExitShell: () => void;

package/dist/primary/shell/src/features/exit/handler.d.ts

@@ -0,0 +1,10 @@
+import { PrimariaApi } from '../..';
+import { ExitShell } from './request';
+
+export declare class ExitShellHandler {
+    private api;
+    constructor(api: PrimariaApi);
+    handle(message: ExitShell): Promise<void>;
+    private askForClose;
+    private timeout;
+}

package/dist/primary/shell/src/features/exit/request.d.ts

@@ -0,0 +1,4 @@
+import { IRequest } from '../..';
+
+export declare class ExitShell implements IRequest<void> {
+}

package/dist/primary/shell/src/handle-plugins.d.ts

@@ -2,6 +2,6 @@ import { PluginDefinition, Plugin as PluginType } from '@uxland/harmonix';
 import { PrimariaApi } from './api/api';
 
 export type { PluginDefinition, PluginInfo } from '@uxland/harmonix';
-export declare const bootstrapPlugins: (plugins: PluginDefinition[]) => Promise<Plugin[]>;
-export declare const disposePlugins: (plugins: Plugin[]) => Promise<void[]>;
+export declare const bootstrapPlugins: (plugins: PluginDefinition[]) => Promise<void>;
+export declare const disposePlugins: () => Promise<void[]>;
 export type Plugin = PluginType<PrimariaApi>;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/request.d.ts

@@ -7,6 +7,6 @@ export interface InjectAsyncHistoryItemsPayload {
     componentFactory: (item: IActivityHistoryItem) => HTMLElement;
     searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean;
     errorMessage: string;
-    filters?: IActivityHistoryCommonFilterGroup;
+    filters: IActivityHistoryCommonFilterGroup;
 }
 export declare const addAsyncHistoryItemsCommand = "inject_async_history_items_request";

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/validate-add-async-items-command.d.ts

@@ -0,0 +1,4 @@
+import { IActivityHistoryItem } from '../../domain/model';
+import { InjectAsyncHistoryItemsPayload } from './request';
+
+export declare const validateAddAsyncCommand: (payload: InjectAsyncHistoryItemsPayload, items: IActivityHistoryItem[]) => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/reducer.d.ts

@@ -6,4 +6,4 @@ export declare function addActivityHistoryItemsReducer(state: any, action: Paylo
     items: IActivityHistoryItem[];
     componentFactory?: (item: IActivityHistoryItem) => HTMLElement;
     searchPredicate?: TSearchActivityHistoryItemPredicate;
-}>): void;
+}>): any;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/model.d.ts

@@ -22,6 +22,9 @@ export interface IActivityHistoryItem {
     searchPredicate: TSearchActivityHistoryItemPredicate;
     type?: string;
 }
+export interface IActivityHistoryItemWithComponent extends IActivityHistoryItem {
+    component: HTMLElement;
+}
 export interface IActivityHistoryItemCollection {
     id: string;
     items: IActivityHistoryItem[];

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

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+import { PrimariaApi } from '../../../../../../api/api';
+import { IActivityHistoryCustomFilterGroup, IActivityHistoryFilterGroup } from '../../model';
+
+export declare class ActiveFiltersBadges extends LitElement {
+    render(): import('lit').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+    api: PrimariaApi;
+    activityHistoryCommonFiltersSelector: any;
+    enabledCommonFilters: IActivityHistoryFilterGroup[];
+    enabledFilters: IActivityHistoryCustomFilterGroup[];
+    _onDeleteFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean): void;
+    _onDeleteCommonFilterValue(filterId: string): void;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/template.d.ts

@@ -0,0 +1,4 @@
+import { nothing } from 'lit';
+import { ActiveFiltersBadges } from './active-filters-badges';
+
+export declare const template: (props: ActiveFiltersBadges) => import('lit').TemplateResult<1> | typeof nothing;

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

@@ -0,0 +1,9 @@
+import { LitElement } from 'lit';
+
+export declare class ActiveFiltersHeader extends LitElement {
+    render(): import('lit').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+    searchString: string;
+    areCustomFiltersActive: boolean;
+    areCommonFiltersActive: boolean;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/template.d.ts

@@ -0,0 +1,4 @@
+import { nothing } from 'lit';
+import { ActiveFiltersHeader } from './active-filters-header';
+
+export declare const template: (props: ActiveFiltersHeader) => import('lit').TemplateResult<1> | typeof nothing;

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

@@ -90,3 +90,155 @@ export declare const isEnabledCommonFilterSelector: (filterId: string) => ((stat
     argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
     memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
 };
+export declare const activityHistoryEnabledCommonFiltersSelector: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('..').IActivityHistoryFilterGroup[];
+    };
+}) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[];
+    memoizedResultFunc: ((resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('..').IActivityHistoryFilterGroup[];
+        };
+    }) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('..').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('..').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[];
+        dependencies: [(state: import('../../../infrastructure/state/store').RootState) => import('..').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;
+};
+export declare const areCommonFiltersActive: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('..').IActivityHistoryFilterGroup[];
+    };
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('..').IActivityHistoryFilterGroup[];
+        };
+    }) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => (import('..').IActivityHistoryCommonFilter | import('..').IActivityHistoryCustomFilter)[];
+        dependencies: [((state: {
+            activityHistoryCollections: {
+                busy: import('../../..').IBusyHistoryItem[];
+                error: import('../../..').IErrorHistoryItem[];
+                collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+            };
+            activityHistoryFilters: {
+                searchString: string;
+                filters: import('..').IActivityHistoryFilterGroup[];
+            };
+        }) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import('..').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[];
+            memoizedResultFunc: ((resultFuncArgs_0: import('..').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[];
+            dependencies: [(state: import('../../../infrastructure/state/store').RootState) => import('..').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;
+};

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

@@ -1,4 +1,4 @@
-import { IActivityHistoryFilterGroup } from '../model';
+import { IActivityHistoryCustomFilter, IActivityHistoryFilterGroup } from '../model';
 
 export declare const activityHistoryCustomFilterGroupsSelector: ((state: {
     activityHistoryCollections: {
@@ -31,3 +31,149 @@ export declare const activityHistoryCustomFilterGroupsSelector: ((state: {
     argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
     memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
 };
+export declare const areCustomFiltersActive: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: IActivityHistoryFilterGroup[];
+    };
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryFilterGroup[]) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilterGroup[]) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: IActivityHistoryFilterGroup[];
+        };
+    }) => IActivityHistoryFilterGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: IActivityHistoryFilterGroup[]) => IActivityHistoryFilterGroup[];
+        memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilterGroup[]) => IActivityHistoryFilterGroup[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryFilterGroup[];
+        dependencies: [(state: import('../../../infrastructure/state/store').RootState) => 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;
+};
+export declare const activeGroupsWithEnabledFilters: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: IActivityHistoryFilterGroup[];
+    };
+}) => {
+    id: string;
+    title: string;
+    enabled: boolean;
+    sort: string;
+    filters: IActivityHistoryCustomFilter[];
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryFilterGroup[]) => {
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+        filters: IActivityHistoryCustomFilter[];
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilterGroup[]) => {
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+        filters: IActivityHistoryCustomFilter[];
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+        filters: IActivityHistoryCustomFilter[];
+    }[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: IActivityHistoryFilterGroup[];
+        };
+    }) => IActivityHistoryFilterGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: IActivityHistoryFilterGroup[]) => IActivityHistoryFilterGroup[];
+        memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilterGroup[]) => IActivityHistoryFilterGroup[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryFilterGroup[];
+        dependencies: [(state: import('../../../infrastructure/state/store').RootState) => 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;
+};

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

@@ -0,0 +1,2 @@
+export declare const formatShowFilterTitle: (title: string) => string;
+export declare const normalizeDeletedFilterBooleanValue: (value: any) => any;

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

@@ -10,6 +10,8 @@ export declare class ActivityHistoryTimeline extends LitElement {
     searchString: string;
     _hasUpdatedOnce: boolean;
     firstUpdated(): void;
+    updated(changedProperties: any): Promise<void>;
+    prepareComponents(historyGroups: any): Promise<void>;
     highlightMatch(text: string, searchString: string): string;
     _scrollIntoDate(selectedDate: number): void;
 }

package/dist/primary/shell/src/internal-plugins/activity-history/handle-views.d.ts

@@ -0,0 +1,4 @@
+import { PrimariaApi } from '../../api/api';
+
+export declare const registerViews: (api: PrimariaApi) => void;
+export declare const unregisterViews: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/ioc/container.d.ts

@@ -5,3 +5,4 @@ declare const container: Container;
 declare const lazyInject: (serviceIdentifier: string | symbol | import("inversify").interfaces.Newable<any> | import("inversify").interfaces.Abstract<any>) => (proto: any, key: string) => void;
 export { container, lazyInject };
 export declare const bindDeps: (api: PrimariaApi) => void;
+export declare const unbindDeps: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/ioc/types.d.ts

@@ -1,5 +1,4 @@
 export declare const TYPES: {
     primaryApi: symbol;
     store: symbol;
-    localeManager: symbol;
 };

package/dist/primary/shell/src/internal-plugins/activity-history/localization.d.ts

@@ -50,6 +50,7 @@ export declare const locales: {
                 clinicalCourseType: string;
                 selected: string;
                 applyFilters: string;
+                deleted: string;
             };
             tooltips: {
                 subjective: string;
@@ -61,6 +62,9 @@ export declare const locales: {
                 variablees: string;
                 prescriptions: string;
             };
+            chipHeader: {
+                selection: string;
+            };
         };
     };
 };

package/dist/primary/shell/src/internal-plugins/activity-history/main.d.ts

@@ -2,4 +2,3 @@ import { PrimariaApi } from '../../api/api';
 
 export declare const initialize: (api: PrimariaApi) => Promise<void>;
 export declare const dispose: () => Promise<void>;
-export declare const registerViews: (api: PrimariaApi) => void;

package/dist/primary/shell/src/locales.d.ts

@@ -17,6 +17,7 @@ export declare const locales: {
                 create: string;
                 toggleMenuClose: string;
                 toggleMenuOpen: string;
+                askExit: string;
             };
             clinicalMonitoring: {
                 title: string;
@@ -26,6 +27,9 @@ export declare const locales: {
                 role: string;
                 speciality: string;
             };
+            busyManager: {
+                title: string;
+            };
         };
     };
 };