@uxland/primary-shell 3.5.4 → 4.0.0

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

@@ -1,2 +1,3 @@
 
 export * from './primaria-interaction';
+export { PrimariaContentSwitcher } from './primaria-content-switcher/primaria-content-switcher';

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

@@ -5,6 +5,7 @@ export * from './api/region-manager/regions';
 export * from './handle-plugins';
 export * from './api/api';
 export * from './api/broker/primaria-broker';
+export * from './UI/index';
 export { PrimariaNavItem } from './UI/shared-components/primaria-nav-item/primaria-nav-item';
 export { confirmMixin } from './UI/shared-components/primaria-interaction';
 export type { CustomConfirmOptions } from './UI/shared-components/primaria-interaction';

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

@@ -1,11 +1,12 @@
 import { IActivityHistoryItem } from '../../domain/model';
+import { IActivityHistoryCommonFilterGroup } from '../../filter';
 
 export interface InjectAsyncHistoryItemsPayload {
     entityId: string;
-    asyncTask: () => Promise<any>;
-    mapFn?: (item: any) => any;
+    asyncDataProvider: () => Promise<IActivityHistoryItem[]>;
     componentFactory: (item: IActivityHistoryItem) => HTMLElement;
-    searchPredicate?: (searchString: string, item: any) => boolean;
+    searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean;
     errorMessage: string;
+    filters?: IActivityHistoryCommonFilterGroup;
 }
-export declare const injectAsyncHistoryItemsRequest = "inject_async_history_items_request";
+export declare const addAsyncHistoryItemsCommand = "inject_async_history_items_request";

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

@@ -4,4 +4,4 @@ export interface AddHistoryItemPayload {
     entityId: string;
     item: IActivityHistoryItem;
 }
-export declare const addHistoryItemRequest = "add_history_item_request";
+export declare const addHistoryItemCommand = "add_history_item_request";

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

@@ -6,4 +6,4 @@ export interface AddHistoryItemsPayload {
     componentFactory?: (item: IActivityHistoryItem) => HTMLElement;
     searchPredicate?: (searchString: string, item: any) => boolean;
 }
-export declare const addHistoryItemsRequest = "add_history_items_request";
+export declare const addHistoryItemsCommand = "add_history_items_request";

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

@@ -0,0 +1,9 @@
+import { IActivityHistoryCommonFilter } from '../../filter';
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class CommonFilterSpec extends Spec<IActivityHistoryItem> {
+    private commonFilters;
+    constructor(commonFilters: IActivityHistoryCommonFilter[]);
+    isSatisfiedBy(item: IActivityHistoryItem): boolean;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/specs/custom-filter-spec.d.ts

@@ -0,0 +1,10 @@
+import { IActivityHistoryCustomFilterGroup } from '../../filter';
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class CustomFilterSpec extends Spec<IActivityHistoryItem> {
+    private filters;
+    constructor(filters: IActivityHistoryCustomFilterGroup[]);
+    isSatisfiedBy(item: IActivityHistoryItem): boolean;
+    private belongsToGroup;
+}

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

@@ -0,0 +1,6 @@
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class FalseSpec extends Spec<IActivityHistoryItem> {
+    isSatisfiedBy(): boolean;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/specs/prop-path-spec.d.ts

@@ -0,0 +1,9 @@
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class PropPathSpec extends Spec<IActivityHistoryItem> {
+    propPath: string[];
+    private value;
+    constructor(propPath: string[], value: any);
+    isSatisfiedBy(context: IActivityHistoryItem): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { IActivityHistoryCustomFilterGroup } from '../../filter';
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class TypeSpec extends Spec<IActivityHistoryItem> {
+    itemType: string;
+    constructor(itemType: string);
+    isSatisfiedBy(context: IActivityHistoryItem): boolean;
+}
+export declare class ComposedTypeSpec extends Spec<IActivityHistoryItem> {
+    filters: IActivityHistoryCustomFilterGroup[];
+    constructor(filters: IActivityHistoryCustomFilterGroup[]);
+    isSatisfiedBy(item: IActivityHistoryItem): boolean;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/export-to-pdf/export-pdf-modal/export-pdf-modal.d.ts

@@ -1,6 +1,6 @@
 import { LitElement } from 'lit';
 
-declare const ExportPdfModal_base: import('../../../../../UI').Constructor<import('../../../../../UI').ConfirmMixinBase> & typeof LitElement;
+declare const ExportPdfModal_base: import('../../../../..').Constructor<import('../../../../..').ConfirmMixinBase> & typeof LitElement;
 export declare class ExportPdfModal extends ExportPdfModal_base {
     render(): import('lit').TemplateResult<1>;
     static get styles(): import('lit').CSSResult;

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

@@ -1,13 +1,18 @@
 import { LitElement } from 'lit';
 import { PrimariaApi } from '../../../../../../api/api';
-import { IActivityHistoryFilter } from '../../model';
+import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup } from '../../model';
 
 export declare class ActivityHistoryFilters extends LitElement {
     render(): import('lit').TemplateResult<1>;
     static styles: import('lit').CSSResult;
-    filters: IActivityHistoryFilter[];
+    commonFilters: IActivityHistoryCommonFilter[];
+    customFilterGroups: IActivityHistoryCustomFilterGroup[];
     api: PrimariaApi;
     filtersExpanded: boolean;
+    wrapperMaximized: boolean;
+    updated(changedProperties: any): void;
     _toggleFilters(): void;
     _onChangeCommonFilterValue(filterId: string, value: boolean): void;
+    _onChangeCustomFilterGroupValue(filterGroupId: string, value: boolean): void;
+    _onChangeCustomFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean): void;
 }

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

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

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

@@ -0,0 +1,92 @@
+export declare const activityHistoryCommonFiltersSelector: ((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;
+};
+export declare const isEnabledCommonFilterSelector: (filterId: string) => ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('..').IActivityHistoryFilterGroup[];
+    };
+}) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import('..').IActivityHistoryCommonFilter[] | import('..').IActivityHistoryCustomFilter[]) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    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;
+};

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

@@ -0,0 +1,4 @@
+export declare const setCommonFilterValue: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    id: string;
+    enabled: boolean;
+}, "activity-history-filters/setCommonFilterValue">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/{set-common-filter → common-filters/set-common-filter}/handler.d.ts

@@ -1,4 +1,4 @@
-import { StoreBaseHandler } from '../../../infrastructure/base-handlers';
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
 import { SetCommonFilter } from './request';
 
 export declare class SetCommonFilterHandler extends StoreBaseHandler {

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

@@ -0,0 +1,6 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+
+export declare function setCommonFilterValueReducer(state: any, action: PayloadAction<{
+    id: string;
+    enabled: boolean;
+}>): void;

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

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

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

@@ -0,0 +1,4 @@
+import { BrokerExtensions } from '@primaria/plugins-core';
+
+export declare const bootstrapAddCustomFilter: (broker: BrokerExtensions) => void;
+export declare const teardownAddCustomFilter: () => void;

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

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
+import { AddCustomFiltersCommand } from './request';
+
+export declare class AddCustomFiltersHandler extends StoreBaseHandler {
+    handle(request: AddCustomFiltersCommand): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IActivityHistoryCommonFilterGroup } from '../model';
+
+export declare function addCustomFiltersReducer(state: any, action: PayloadAction<IActivityHistoryCommonFilterGroup>): void;

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

@@ -0,0 +1,6 @@
+import { IActivityHistoryCommonFilterGroup } from '../model';
+
+export declare class AddCustomFiltersCommand {
+    payload: IActivityHistoryCommonFilterGroup;
+    constructor(payload: IActivityHistoryCommonFilterGroup);
+}

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

@@ -0,0 +1,33 @@
+import { IActivityHistoryFilterGroup } from '../model';
+
+export declare const activityHistoryCustomFilterGroupsSelector: ((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;
+};

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

@@ -0,0 +1,4 @@
+export declare const setCustomFilterGroupValue: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    id: string;
+    enabled: boolean;
+}, "activity-history-filters/setCustomFilterGroupValue">;

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

@@ -0,0 +1,4 @@
+import { BrokerExtensions } from '@primaria/plugins-core';
+
+export declare const bootstrapSetCustomFilterGroup: (broker: BrokerExtensions) => void;
+export declare const teardownSetCustomFilterGroup: () => void;

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

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
+import { SetCustomFilterGroup } from './request';
+
+export declare class SetCustomFilterGroupHandler extends StoreBaseHandler {
+    handle(request: SetCustomFilterGroup): Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+
+export declare function setCustomFilterGroupValueReducer(state: any, action: PayloadAction<{
+    id: string;
+    enabled: boolean;
+}>): void;

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

@@ -0,0 +1,10 @@
+export declare class SetCustomFilterGroup {
+    payload: {
+        id: string;
+        enabled: boolean;
+    };
+    constructor(payload: {
+        id: string;
+        enabled: boolean;
+    });
+}

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

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

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

@@ -0,0 +1,4 @@
+import { BrokerExtensions } from '@primaria/plugins-core';
+
+export declare const bootstrapSetCustomFilterValue: (broker: BrokerExtensions) => void;
+export declare const teardownSetCustomFilterValue: () => void;

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

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
+import { SetCustomFilterValue } from './request';
+
+export declare class SetCustomFilterValueHandler extends StoreBaseHandler {
+    handle(request: SetCustomFilterValue): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { SetCustomFilterValuePayload } from './request';
+
+export declare function setCustomFilterValueReducer(state: any, action: PayloadAction<SetCustomFilterValuePayload>): void;

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

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

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

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

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

@@ -1,19 +1,49 @@
 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 declare enum ActivityHistoryFilterType {
+    Switch = "switch",
+    Checkbox = "checkbox"
+}
+export declare 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 declare const isCommonFilterGroup: (group: IActivityHistoryFilterGroup) => boolean;
+export declare const isNotCommonFilterGroup: (group: IActivityHistoryFilterGroup) => boolean;
 export {};

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

@@ -1,157 +1,3 @@
 import { RootState } from '../../infrastructure/state/store';
-import { IActivityHistoryFilter } from './model';
 
 export declare const activityHistoryFiltersSelector: (state: RootState) => import('./model').IActivityHistoryFilterGroup[];
-export declare const activityHistoryCommonFiltersSelector: ((state: {
-    activityHistoryCollections: {
-        busy: import('../..').IBusyHistoryItem[];
-        error: import('../..').IErrorHistoryItem[];
-        collections: Record<string, import('../..').IActivityHistoryItemCollection>;
-    };
-    activityHistoryFilters: {
-        searchString: string;
-        filters: import('./model').IActivityHistoryFilterGroup[];
-    };
-}) => IActivityHistoryFilter[] | undefined) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined;
-    memoizedResultFunc: ((resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => IActivityHistoryFilter[] | undefined;
-    dependencies: [(state: RootState) => import('./model').IActivityHistoryFilterGroup[]];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
-};
-export declare const isEnabledCommonFilterSelector: (filterId: string) => ((state: {
-    activityHistoryCollections: {
-        busy: import('../..').IBusyHistoryItem[];
-        error: import('../..').IErrorHistoryItem[];
-        collections: Record<string, import('../..').IActivityHistoryItemCollection>;
-    };
-    activityHistoryFilters: {
-        searchString: string;
-        filters: import('./model').IActivityHistoryFilterGroup[];
-    };
-}) => boolean | undefined) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: IActivityHistoryFilter[] | undefined) => boolean | undefined;
-    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter[] | undefined) => boolean | undefined) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => boolean | undefined;
-    dependencies: [((state: {
-        activityHistoryCollections: {
-            busy: import('../..').IBusyHistoryItem[];
-            error: import('../..').IErrorHistoryItem[];
-            collections: Record<string, import('../..').IActivityHistoryItemCollection>;
-        };
-        activityHistoryFilters: {
-            searchString: string;
-            filters: import('./model').IActivityHistoryFilterGroup[];
-        };
-    }) => IActivityHistoryFilter[] | undefined) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    } & {
-        resultFunc: (resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined;
-        memoizedResultFunc: ((resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined) & {
-            clearCache: () => void;
-            resultsCount: () => number;
-            resetResultsCount: () => void;
-        };
-        lastResult: () => IActivityHistoryFilter[] | undefined;
-        dependencies: [(state: RootState) => import('./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;
-};
-export declare const commonSpecSelector: ((state: {
-    activityHistoryCollections: {
-        busy: import('../..').IBusyHistoryItem[];
-        error: import('../..').IErrorHistoryItem[];
-        collections: Record<string, import('../..').IActivityHistoryItemCollection>;
-    };
-    activityHistoryFilters: {
-        searchString: string;
-        filters: import('./model').IActivityHistoryFilterGroup[];
-    };
-}) => import('../domain/specs/spec').ISpec<import('../..').IActivityHistoryItem>) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<import('../..').IActivityHistoryItem>;
-    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<import('../..').IActivityHistoryItem>) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => import('../domain/specs/spec').ISpec<import('../..').IActivityHistoryItem>;
-    dependencies: [((state: {
-        activityHistoryCollections: {
-            busy: import('../..').IBusyHistoryItem[];
-            error: import('../..').IErrorHistoryItem[];
-            collections: Record<string, import('../..').IActivityHistoryItemCollection>;
-        };
-        activityHistoryFilters: {
-            searchString: string;
-            filters: import('./model').IActivityHistoryFilterGroup[];
-        };
-    }) => IActivityHistoryFilter[] | undefined) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    } & {
-        resultFunc: (resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined;
-        memoizedResultFunc: ((resultFuncArgs_0: import('./model').IActivityHistoryFilterGroup[]) => IActivityHistoryFilter[] | undefined) & {
-            clearCache: () => void;
-            resultsCount: () => number;
-            resetResultsCount: () => void;
-        };
-        lastResult: () => IActivityHistoryFilter[] | undefined;
-        dependencies: [(state: RootState) => import('./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;
-};

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

@@ -0,0 +1,20 @@
+import { setSearchStringReducer } from '../search/reducer';
+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 declare const activityHistoryFiltersSlice: import('@reduxjs/toolkit').Slice<{
+    searchString: string;
+    filters: IActivityHistoryFilterGroup[];
+}, {
+    setSearchString: typeof setSearchStringReducer;
+    setCommonFilterValue: typeof setCommonFilterValueReducer;
+    addCustomFilters: typeof addCustomFiltersReducer;
+    setCustomFilterGroupValue: typeof setCustomFilterGroupValueReducer;
+    setCustomFilterValue: typeof setCustomFilterValueReducer;
+}, "activity-history-filters", "activity-history-filters", import('@reduxjs/toolkit').SliceSelectors<{
+    searchString: string;
+    filters: IActivityHistoryFilterGroup[];
+}>>;