@omnia/wcm 8.0.1-dev → 8.0.2-dev

package/internal-do-not-import-from-here/fx/stores/NavigationStore.d.ts

@@ -0,0 +1,76 @@
+import { Store } from "@omnia/fx/stores";
+import { NavigationData, NavigationNode, NavigationPosition, NodeId, NavigationResult, NavigationDataType, PageId, MoveNavigationNodeResult, LinkNavigationData, VariationId, PageCollectionNavigationNode, PageCollectionNavigationData } from "../models";
+export declare class NavigationStore extends Store {
+    private navigationService;
+    private variationsStore;
+    private publishingAppInfoStore;
+    private omniaContext;
+    private wcmContext;
+    private idToNodeMap;
+    private children;
+    private parentIdToChildLoadPromisesMap;
+    private pageNodePromiseMap;
+    filterActions: {
+        pageCollections: (node: NavigationNode<NavigationData>) => boolean;
+        allExceptPageTypes: (node: NavigationNode<NavigationData>) => boolean;
+        pageTypes: (node: NavigationNode<NavigationData>) => boolean;
+        filterNotSoftDeleted: (node: NavigationNode<NavigationData>) => boolean;
+    };
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        getFilteredNodes: <T extends NavigationNode<NavigationData>>(filterAction: (node: NavigationNode<NavigationData>) => boolean) => T[];
+        getFilteredByType: (nodeTypes?: NavigationDataType) => Array<NavigationNode<NavigationData>>;
+        getById: (nodeId: NodeId) => NavigationNode<NavigationData>;
+        getByPageId: (pageId: PageId) => NavigationNode<NavigationData>;
+        getChildren: (node: NavigationNode<NavigationData>, forceFromPublishingAppId?: string) => Array<NavigationNode<NavigationData>>;
+        isLoadingChildren: (node: NavigationNode<NavigationData>) => boolean;
+        hasChildrenLoadTriggered: (node: NavigationNode<NavigationData>) => boolean;
+        getParents: <T_1 extends NavigationNode<NavigationData>>(node: NavigationNode<NavigationData>, nodeTypes?: NavigationDataType) => T_1[];
+        absoluteUrl: (node: NavigationNode<NavigationData>, variationId?: VariationId, excludeVariationUrl?: boolean) => string;
+        sortSiblingNodes: (nodes: Array<NavigationNode<NavigationData>>) => NavigationNode<NavigationData>[];
+        checkNodeIsDefaultPageCollectionNode: (navigationNode: PageCollectionNavigationNode<PageCollectionNavigationData>) => boolean;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        addOrUpdateNodes: import("@omnia/fx/stores").StoreMutation<(nodes: Array<NavigationNode<NavigationData>>) => void, (nodes: NavigationNode<NavigationData>[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        delete: import("@omnia/fx/stores").StoreMutation<(node: NavigationNode<NavigationData>) => void, (node: NavigationNode<NavigationData>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        deleteAll: import("@omnia/fx/stores").StoreMutation<() => void, () => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        /**
+         * Updates the data part of the node, i.e. NavigationNode.navigationData
+         * */
+        updateNodeData: import("@omnia/fx/stores").StoreAction<unknown, (node: NavigationNode<NavigationData>) => void, (result: void, node: NavigationNode<NavigationData>) => void, (failureReason: any, node: NavigationNode<NavigationData>) => void, <T extends NavigationNode<NavigationData>>(node: T) => Promise<void>>;
+        createNode: import("@omnia/fx/stores").StoreAction<unknown, (nodeData: NavigationData, position: NavigationPosition) => void, (result: NavigationNode<NavigationData>, nodeData: NavigationData, position: NavigationPosition) => void, (failureReason: any, nodeData: NavigationData, position: NavigationPosition) => void, <T_1 extends NavigationData>(nodeData: T_1, position: NavigationPosition) => Promise<NavigationNode<NavigationData>>>;
+        moveNode: import("@omnia/fx/stores").StoreAction<unknown, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (result: void, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (failureReason: any, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => Promise<void>>;
+        movePageNode: import("@omnia/fx/stores").StoreAction<unknown, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition, moveResult: MoveNavigationNodeResult) => void, (result: void, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition, moveResult: MoveNavigationNodeResult) => void, (failureReason: any, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition, moveResult: MoveNavigationNodeResult) => void, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition, moveResult: MoveNavigationNodeResult) => Promise<void>>;
+        movePageCollection: import("@omnia/fx/stores").StoreAction<unknown, (pageCollectionId: number, targetPublishingAppId: string) => void, (result: number[], pageCollectionId: number, targetPublishingAppId: string) => void, (failureReason: any, pageCollectionId: number, targetPublishingAppId: string) => void, (pageCollectionId: number, targetPublishingAppId: string) => Promise<number[]>>;
+        ensureNodesWithPageIds: import("@omnia/fx/stores").StoreAction<unknown, (...args: PageId[]) => void, (result: void, ...args: PageId[]) => void, (failureReason: any, ...args: PageId[]) => void, (...pageIds: Array<PageId>) => Promise<void>>;
+        ensureChildren: import("@omnia/fx/stores").StoreAction<unknown, (node: NavigationNode<NavigationData>, depth?: number, forceFromPublishingAppId?: string) => void, (result: void, node: NavigationNode<NavigationData>, depth?: number, forceFromPublishingAppId?: string) => void, (failureReason: any, node: NavigationNode<NavigationData>, depth?: number, forceFromPublishingAppId?: string) => void, (node: NavigationNode<NavigationData>, depth?: number, forceFromPublishingAppId?: string) => Promise<void>>;
+        ensureTreeForNode: import("@omnia/fx/stores").StoreAction<unknown, (node: NavigationNode<NavigationData>) => void, (result: NavigationResult, node: NavigationNode<NavigationData>) => void, (failureReason: any, node: NavigationNode<NavigationData>) => void, (node: NavigationNode<NavigationData>) => Promise<NavigationResult>>;
+        ensureTreeForPath: import("@omnia/fx/stores").StoreAction<unknown, (path: string) => void, (result: NavigationResult, path: string) => void, (failureReason: any, path: string) => void, (path: string) => Promise<NavigationResult>>;
+        refreshRoot: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        refresh: import("@omnia/fx/stores").StoreAction<unknown, (nodes: NavigationNode<NavigationData>[]) => void, (result: void, nodes: NavigationNode<NavigationData>[]) => void, (failureReason: any, nodes: NavigationNode<NavigationData>[]) => void, (nodes: Array<NavigationNode<NavigationData>>) => Promise<void>>;
+        handleDeletedNodes: import("@omnia/fx/stores").StoreAction<unknown, (deletedNodes: NavigationNode<NavigationData>[]) => void, (result: void, deletedNodes: NavigationNode<NavigationData>[]) => void, (failureReason: any, deletedNodes: NavigationNode<NavigationData>[]) => void, (deletedNodes: Array<NavigationNode<NavigationData>>) => Promise<void>>;
+        deleteLinkNode: import("@omnia/fx/stores").StoreAction<unknown, (nodeToDelete: NavigationNode<LinkNavigationData>) => void, (result: void, nodeToDelete: NavigationNode<LinkNavigationData>) => void, (failureReason: any, nodeToDelete: NavigationNode<LinkNavigationData>) => void, (nodeToDelete: NavigationNode<LinkNavigationData>) => Promise<void>>;
+        ensureParents: import("@omnia/fx/stores").StoreAction<unknown, (node: NavigationNode<NavigationData>) => void, (result: void, node: NavigationNode<NavigationData>) => void, (failureReason: any, node: NavigationNode<NavigationData>) => void, (node: NavigationNode<NavigationData>) => Promise<void>>;
+    };
+    private handleNavigationResult;
+    private ensureChildrenPromiseFulfilled;
+    private addOrUpdate;
+    private sortSiblingNodes;
+    private getChildKey;
+    private getParentKey;
+    private getChildrenLoadPromise;
+    private getChildrenLoadPromiseKey;
+    private cleanChildrenLoadPromise;
+    private getRoutePathFromPubappInfo;
+    private get publishingAppId();
+    private getDefaultRoute;
+}

package/internal-do-not-import-from-here/fx/stores/PageBlockPropertyStore.d.ts

@@ -0,0 +1,27 @@
+import { IBlockInstance } from "@omnia/fx-models";
+import { BlockConfiguration, IPageBlockPropertyStore, PropertyMapping, ReactivePageBlockProperty, VersionId } from "../models";
+export declare class PageBlockPropertyStore implements IPageBlockPropertyStore {
+    private _propertyBagState;
+    private _enterprisePropertiesState;
+    private _blockConfiguration;
+    private _currentPageStore;
+    private _isCheckedoutVersion;
+    private _vm;
+    private _currentVersionPageId;
+    private _pageType;
+    constructor();
+    onPropertyUpdated(state: {
+        [key: string]: ReactivePageBlockProperty<unknown>;
+    }, key: string, value: unknown): void;
+    getPropertyMapping<BlockSettings>(blockInstance: IBlockInstance<BlockSettings>, blockSettings: BlockSettings): PropertyMapping;
+    setConfiguration<BlockSettings>(blockInstance: IBlockInstance<BlockSettings>, configuration: BlockConfiguration): void;
+    getConfiguration<BlockSettings>(blockInstance: IBlockInstance<BlockSettings>): BlockConfiguration;
+    allowSetDefaultContent<BlockSettings>(blockInstance: IBlockInstance<BlockSettings>): boolean;
+    allowOverrideInWriteMode<BlockSettings>(blockInstance: IBlockInstance<BlockSettings>, blockSettings: BlockSettings): boolean;
+    updateBlockProperty<T>(reactivePageProperty: ReactivePageBlockProperty<T>): void;
+    getBlockProperty<BlockSettings, BlockProperty>(blockInstance: IBlockInstance<BlockSettings>, blockSettings: BlockSettings, defaultBlockProperty: BlockProperty, nullOrUndefinedValueCustomHandler?: (missingPropertyName: string, parent: object, defaultValue: object) => object, emptyStringValueCustomHandler?: (missingPropertyName: string, parent: object, defaultValue: object) => object, emptyArrayValueCustomHandler?: (missingPropertyName: string, parent: object, defaultValue: object) => object): ReactivePageBlockProperty<BlockProperty>;
+    ensureRemoveDeletedBlockProperty(): void;
+    get CurrentVersionPageId(): VersionId;
+    destroy(): void;
+    private createReactiveProperty;
+}

package/internal-do-not-import-from-here/fx/stores/PageRollupStore.d.ts

@@ -0,0 +1,134 @@
+import { Store } from "@omnia/fx/stores";
+import { PageDetailQueryResult, PageDialogData, PageDialogPropertiesMapping, PageNavigationData, PageNavigationNode, PageRollupQuery, ExportQueryPagesRequest, ExportQueryPagesResult, PageTypeTitle } from "@omnia/wcm/models";
+export interface PageRollupQueryResult extends PageRollupQuery {
+    selectProperties: Array<string>;
+    disableDistinct: boolean;
+    resultIds: Array<number>;
+    total: number;
+    errMsg: string;
+    concatResult?: boolean;
+    showMetric?: boolean;
+}
+type BatchPageRollupQueryResult = {
+    queries: PageRollupQueryResult[];
+    pagesDetailResult: PageDetailQueryResult[];
+};
+export declare class PageRollupStore extends Store {
+    private pageQueryService;
+    private navigationStore;
+    private appInfoStore;
+    private multilingualStore;
+    private omniaCtx;
+    private wcmRouter;
+    private pagesStore;
+    private pageService;
+    private appsLoc;
+    /**
+     * State
+     */
+    pages: import("@omnia/fx/stores").StoreState<{
+        [uniqueKey: string]: PageDetailQueryResult[];
+    }>;
+    pagesLoadingStatus: import("@omnia/fx/stores").StoreState<{
+        [uniqueKey: string]: boolean;
+    }>;
+    pagesData: import("@omnia/fx/stores").StoreState<{
+        [pageId: number]: PageDialogData;
+    }>;
+    pagesContentWithLimit: import("@omnia/fx/stores").StoreState<{
+        [contentLimitId: string]: {
+            [pageId: number]: string;
+        };
+    }>;
+    totalPages: import("@omnia/fx/stores").StoreState<{
+        [uniqueKey: string]: number;
+    }>;
+    errorMsg: import("@omnia/fx/stores").StoreState<{
+        [uniqueKey: string]: string;
+    }>;
+    private indexedDbPageRollup;
+    private pageTypes;
+    private relevantAppInfo;
+    private pageTypesLoadPromise;
+    private publishingChannelSettings;
+    private loadIndexedDBPromise;
+    private metricUniqueKey;
+    private tenantPublishingAppIdKey;
+    private omniaSearchMigrationStatusPromise;
+    /**
+   * Private properties
+   */
+    private itemQueryResult;
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+     * Getter
+     */
+    getters: {
+        pages: (uniqueKey: string, excludeVariationUrl: boolean) => PageDetailQueryResult[];
+        pagesIndexedDB: (uniqueKey: string) => Promise<Array<PageDetailQueryResult>>;
+        total: (uniqueKey: string, showMetric: boolean) => number;
+        errorMsg: (uniqueKey: string) => string;
+        pageDialogData: (pageId: number) => PageDialogData;
+        pageContentDataWithLimit: (contentProp: string, contentLimit: number, pageId: number) => string;
+        pageTypesTitle: (page: PageDetailQueryResult) => any;
+        pageType: (page: PageDetailQueryResult) => PageTypeTitle;
+        pageTypes: (uniqueKey: string) => PageTypeTitle[];
+        publishingChannelSettings: (uniqueKey: string) => string[];
+        sortPagesByNavigation: (pages: PageDetailQueryResult[], navigationStartNodeId?: number, sortDescending?: boolean) => PageDetailQueryResult[];
+        loadIndexedDb: () => Promise<void>;
+        relevantAppIds: (uniqueKey: string) => {
+            id: string;
+            title: string;
+        }[];
+    };
+    private generatePageSocialCountingAndPageStatisticsColumn;
+    private getPageRollupDataFromIndexedDB;
+    private setPageRollupDataToIndexedDb;
+    /**
+     * Adds an item to the layout.
+     */
+    mutations: {
+        addOrUpdateBatchedPages: import("@omnia/fx/stores").StoreMutation<(data: BatchPageRollupQueryResult, clientCaching: boolean) => void, (data: BatchPageRollupQueryResult, clientCaching: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        addOrUpdateIndexedDBPages: import("@omnia/fx/stores").StoreMutation<(uniqueKey: string, pages: Array<PageDetailQueryResult>) => void, (uniqueKey: string, pages: PageDetailQueryResult[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updatePageTypes: import("@omnia/fx/stores").StoreMutation<(uniqueKey: string, pageTypes: Array<PageTypeTitle>) => void, (uniqueKey: string, pageTypes: PageTypeTitle[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updatePublishingChannelSettings: import("@omnia/fx/stores").StoreMutation<(uniqueKey: string, channelsId: Array<string>) => void, (uniqueKey: string, channelsId: string[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateRollupRelevantAppInfo: import("@omnia/fx/stores").StoreMutation<(uniqueKey: string, appInfo: {
+            id: string;
+            title: string;
+        }[]) => void, (uniqueKey: string, appInfo: {
+            id: string;
+            title: string;
+        }[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        showUniqueUsersDetailsView: import("@omnia/fx/stores").StoreMutation<(pageDetails: PageDetailQueryResult, showView: boolean, blockInstanceId: string) => void, (pageDetails: PageDetailQueryResult, showView: boolean, blockInstanceId: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        navigate: import("@omnia/fx/stores").StoreAction<unknown, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (result: void, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (failureReason: any, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => Promise<void>>;
+        navigateWithVariationTargeting: import("@omnia/fx/stores").StoreAction<unknown, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (result: PageNavigationNode<PageNavigationData>, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (failureReason: any, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => void, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown, event?: MouseEvent) => Promise<PageNavigationNode<PageNavigationData>>>;
+        loadPageContentData: import("@omnia/fx/stores").StoreAction<unknown, (pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit: number, reloadData?: unknown) => void, (result: void, pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit: number, reloadData?: unknown) => void, (failureReason: any, pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit: number, reloadData?: unknown) => void, (pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit: number, reloadData?: unknown) => Promise<void>>;
+        ensureLoadPageTypesInApps: import("@omnia/fx/stores").StoreAction<unknown, (publishingAppIds: string[], includeTenantScope?: boolean) => void, (result: void, publishingAppIds: string[], includeTenantScope?: boolean) => void, (failureReason: any, publishingAppIds: string[], includeTenantScope?: boolean) => void, (publishingAppIds: string[], includeTenantScope?: boolean) => Promise<void>>;
+        ensureLoadPageTypesTitle: import("@omnia/fx/stores").StoreAction<unknown, (pageTypeIds: number[]) => void, (result: void, pageTypeIds: number[]) => void, (failureReason: any, pageTypeIds: number[]) => void, (pageTypeIds: number[]) => Promise<void>>;
+        ensureGetPageTypesTitle: import("@omnia/fx/stores").StoreAction<unknown, (pageTypeIds: number[], uniqueKey: string) => void, (result: PageTypeTitle[], pageTypeIds: number[], uniqueKey: string) => void, (failureReason: any, pageTypeIds: number[], uniqueKey: string) => void, (pageTypeIds: number[], uniqueKey: string) => Promise<Array<PageTypeTitle>>>;
+        ensureGetRelevantAppInfo: import("@omnia/fx/stores").StoreAction<unknown, (appIds: string[], uniqueKey: string) => void, (result: {
+            id: string;
+            title: string;
+        }[], appIds: string[], uniqueKey: string) => void, (failureReason: any, appIds: string[], uniqueKey: string) => void, (appIds: string[], uniqueKey: string) => Promise<Array<{
+            id: string;
+            title: string;
+        }>>>;
+        exportToExcel: import("@omnia/fx/stores").StoreAction<unknown, (query: ExportQueryPagesRequest, exportingBlockId: string) => void, (result: ExportQueryPagesResult, query: ExportQueryPagesRequest, exportingBlockId: string) => void, (failureReason: any, query: ExportQueryPagesRequest, exportingBlockId: string) => void, (query: ExportQueryPagesRequest, exportingBlockId: string) => Promise<ExportQueryPagesResult>>;
+        getExportedFile: import("@omnia/fx/stores").StoreAction<unknown, (exportingFileName: string, exportingFileToken: string) => void, (result: void, exportingFileName: string, exportingFileToken: string) => void, (failureReason: any, exportingFileName: string, exportingFileToken: string) => void, (exportingFileName: string, exportingFileToken: string) => Promise<void>>;
+        ensureOmniaSearchMigrationStatus: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
+    };
+    /**
+     * Find page and page variation in specific node
+     * @param node
+     * @param pageId
+     */
+    private findPageInNode;
+    private getPageTypeLoadPromise;
+    private ensureLoadPageTypePromise;
+    private sortPagesByNavigation;
+    private mapPageTypeSelection;
+}
+export {};

package/internal-do-not-import-from-here/fx/stores/PageStatisticsStore.d.ts

@@ -0,0 +1,42 @@
+import { Store } from "@omnia/fx/stores";
+import { UsageReportItem, PageReportOption, ScheduledReportItem, CheckedOutReportItem, ReviewReportItem, DailyStatisticsPerPage, PageStatisticExportStatus, PageReportByUserPropertiesOption } from "../../models";
+import { PagePropertyMappingSetting } from "@omnia/wcm/models";
+export declare class PageStatisticsStore extends Store {
+    private pageStatisticsService;
+    private settingsService;
+    private omniaContext;
+    private static _visitedPages;
+    private pagePropertyMappingSettingsState;
+    getters: {
+        pagePropertyMappingSettings: () => PagePropertyMappingSetting;
+    };
+    setters: {
+        /**
+         * Set new value after page property mapping is updated
+         */
+        updatePagePropertiesMapping(newSetting: string): void;
+    };
+    mutations: {};
+    actions: {
+        registerPageViewed: import("@omnia/fx/stores").StoreAction<unknown, (pageId: number) => void, (result: void, pageId: number) => void, (failureReason: any, pageId: number) => void, (pageId: number) => Promise<void>>;
+        ensurePropertyMappingSettings: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        getUsageReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: UsageReportItem[], reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<UsageReportItem[]>>;
+        getUsageReportByUserProperties: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportByUserPropertiesOption) => void, (result: UsageReportItem, reportOptions: PageReportByUserPropertiesOption) => void, (failureReason: any, reportOptions: PageReportByUserPropertiesOption) => void, (reportOptions: PageReportByUserPropertiesOption) => Promise<UsageReportItem>>;
+        getCheckedOutReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: CheckedOutReportItem[], reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<CheckedOutReportItem[]>>;
+        getReviewReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: ReviewReportItem[], reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<ReviewReportItem[]>>;
+        getScheduledReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: ScheduledReportItem[], reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<ScheduledReportItem[]>>;
+        exportCheckedOutReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: PageStatisticExportStatus, reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<PageStatisticExportStatus>>;
+        exportUsageReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: PageStatisticExportStatus, reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<PageStatisticExportStatus>>;
+        exportReviewReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: PageStatisticExportStatus, reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<PageStatisticExportStatus>>;
+        exportScheduledReport: import("@omnia/fx/stores").StoreAction<unknown, (reportOptions: PageReportOption) => void, (result: PageStatisticExportStatus, reportOptions: PageReportOption) => void, (failureReason: any, reportOptions: PageReportOption) => void, (reportOptions: PageReportOption) => Promise<PageStatisticExportStatus>>;
+        downloadReportFile: import("@omnia/fx/stores").StoreAction<unknown, (pageStatistic: PageStatisticExportStatus) => void, (result: void, pageStatistic: PageStatisticExportStatus) => void, (failureReason: any, pageStatistic: PageStatisticExportStatus) => void, (pageStatistic: PageStatisticExportStatus) => Promise<void>>;
+        getDailyStatisticsPerPage: import("@omnia/fx/stores").StoreAction<unknown, (pageId: number, includeSubPages: boolean) => void, (result: DailyStatisticsPerPage[], pageId: number, includeSubPages: boolean) => void, (failureReason: any, pageId: number, includeSubPages: boolean) => void, (pageId: number, includeSubPages: boolean) => Promise<DailyStatisticsPerPage[]>>;
+    };
+    private submitPageViewed;
+    private downloadReportResult;
+    onActivated(): void;
+    onDisposing(): void;
+    private getPagePropertyMappingSettingKey;
+    private get currentPublishingAppId();
+    private handleContactFilter;
+}

package/internal-do-not-import-from-here/fx/stores/PagesStore.d.ts

@@ -0,0 +1,74 @@
+import { Store } from "@omnia/fx/stores";
+import { NavigationNode, WCMPageTypes, Page, VersionedPageData, PageData, VersionReference, PageId, NavigationPosition, PageNavigationNode, PageNavigationData, MergedPageVersionLayout, NavigationData, VersionId, VariationPage, Variation, PageCollectionSelection, CheckedOutVersionPageData, ArchivePageResult, PageWithNavigationCreationRequest, ReadNews, ApprovalMetaData } from "../models";
+import { GuidValue, Guid, IMessageBusSubscriptionHandler, IOmniaContext } from "@omnia/fx-models";
+export declare class PagesStore extends Store {
+    private pageService;
+    private navigationStore;
+    private wcmContext;
+    private versionedLayoutStore;
+    protected omniaContext: IOmniaContext;
+    private pages;
+    private versionData;
+    private versionLoadPromise;
+    private pageCollectionSelectionsPromises;
+    private subscriptionHandler;
+    private sitePagesFolderFullUrlPromises;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        getPage: (pageId: PageId) => Page;
+        getFilteredPages: (filterAction: (page: Page) => boolean) => Array<Page>;
+        getPagesByType: (typesToGet?: WCMPageTypes, excludeUnavailable?: boolean) => Array<Page>;
+        getVersion: <T extends VersionedPageData<PageData>>(versionRef: VersionReference) => T;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        addOrUpdatePages: import("@omnia/fx/stores").StoreMutation<(pages: Array<Page>) => void, (pages: Page[]) => IMessageBusSubscriptionHandler>;
+        /**
+         * Removes a page from the store, note use action to do a proper delete
+         * */
+        deletePage: import("@omnia/fx/stores").StoreMutation<(pageId: PageId) => void, (pageId: PageId) => IMessageBusSubscriptionHandler>;
+        deletePageVariation: import("@omnia/fx/stores").StoreMutation<(pageId: PageId, variationId: number) => void, (pageId: PageId, variationId: number) => IMessageBusSubscriptionHandler>;
+        updatePagesSecurityResource: import("@omnia/fx/stores").StoreMutation<(pageIds: number[], securityResourceId: Guid) => void, (pageIds: number[], securityResourceId: Guid) => IMessageBusSubscriptionHandler>;
+        updatePageHidden: import("@omnia/fx/stores").StoreMutation<(pageIds: PageId[], hiddenBy: PageId) => void, (pageIds: PageId[], hiddenBy: PageId) => IMessageBusSubscriptionHandler>;
+        updatePageSoftDeleted: import("@omnia/fx/stores").StoreMutation<(pageIds: PageId[], softDeletedAt: string, previousDeletedAt?: string) => void, (pageIds: PageId[], softDeletedAt: string, previousDeletedAt?: string) => IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        /**
+         * Makes sure pages are in the store
+         * If not using cache any pages already loaded client side will still be reloaded, i.e. a refresh
+         * */
+        ensurePages: import("@omnia/fx/stores").StoreAction<unknown, (pageIds: PageId[], useCachedData?: boolean) => void, (result: void, pageIds: PageId[], useCachedData?: boolean) => void, (failureReason: any, pageIds: PageId[], useCachedData?: boolean) => void, (pageIds: Array<PageId>, useCachedData?: boolean) => Promise<void>>;
+        ensurePagesByType: import("@omnia/fx/stores").StoreAction<unknown, (typesToGet?: number, isTenantPageTypeIncluded?: boolean) => void, (result: void, typesToGet?: number, isTenantPageTypeIncluded?: boolean) => void, (failureReason: any, typesToGet?: number, isTenantPageTypeIncluded?: boolean) => void, (typesToGet?: number, isTenantPageTypeIncluded?: boolean) => Promise<void>>;
+        ensureVersionData: import("@omnia/fx/stores").StoreAction<unknown, (versionRefs: VersionReference[], force?: boolean) => void, (result: MergedPageVersionLayout[], versionRefs: VersionReference[], force?: boolean) => void, (failureReason: any, versionRefs: VersionReference[], force?: boolean) => void, (versionRefs: Array<VersionReference>, force?: boolean) => Promise<MergedPageVersionLayout[]>>;
+        createPage: import("@omnia/fx/stores").StoreAction<unknown, (creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, (result: PageNavigationNode<PageNavigationData>, creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, (failureReason: any, creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, <T extends PageData>(creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => Promise<PageNavigationNode<PageNavigationData>>>;
+        movePage: import("@omnia/fx/stores").StoreAction<unknown, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (result: void, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (failureReason: any, navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => void, (navigationNode: NavigationNode<NavigationData>, newPosition: NavigationPosition) => Promise<void>>;
+        /**
+        * Move a page type from current publishing app to tenant level.
+        */
+        movePageTypeToTenant: import("@omnia/fx/stores").StoreAction<unknown, (page: Page) => void, (result: any, page: Page) => void, (failureReason: any, page: Page) => void, (page: Page) => Promise<any>>;
+        revert: import("@omnia/fx/stores").StoreAction<unknown, (versiontoRevert: VersionedPageData<PageData>) => void, (result: VersionedPageData<PageData>, versiontoRevert: VersionedPageData<PageData>) => void, (failureReason: any, versiontoRevert: VersionedPageData<PageData>) => void, (versiontoRevert: VersionedPageData<PageData>) => Promise<VersionedPageData<PageData>>>;
+        createPageWithVariation: import("@omnia/fx/stores").StoreAction<unknown, (originalPage: Page, pageData: PageData, variation: Variation) => void, (result: VariationPage, originalPage: Page, pageData: PageData, variation: Variation) => void, (failureReason: any, originalPage: Page, pageData: PageData, variation: Variation) => void, <T_1 extends PageData>(originalPage: Page, pageData: T_1, variation: Variation) => Promise<VariationPage>>;
+        ensurePageCollectionSelections: import("@omnia/fx/stores").StoreAction<unknown, (fromPublishingAppId: string, fromPageCollectionIds?: string[]) => void, (result: PageCollectionSelection[], fromPublishingAppId: string, fromPageCollectionIds?: string[]) => void, (failureReason: any, fromPublishingAppId: string, fromPageCollectionIds?: string[]) => void, (fromPublishingAppId: string, fromPageCollectionIds?: Array<string>) => Promise<PageCollectionSelection[]>>;
+        takeOverCheckOutPage: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: CheckedOutVersionPageData<PageData>, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<CheckedOutVersionPageData<PageData>>>;
+        getPage: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId, forceFromPublishingAppId?: string) => void, (result: Page, pageId: PageId, forceFromPublishingAppId?: string) => void, (failureReason: any, pageId: PageId, forceFromPublishingAppId?: string) => void, (pageId: PageId, forceFromPublishingAppId?: string) => Promise<Page>>;
+        archive: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId, comment: string) => void, (result: ArchivePageResult, pageId: PageId, comment: string) => void, (failureReason: any, pageId: PageId, comment: string) => void, (pageId: PageId, comment: string) => Promise<ArchivePageResult>>;
+        copy: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId, targetParentPageId?: PageId) => void, (result: PageNavigationNode<PageNavigationData>, pageId: PageId, targetParentPageId?: PageId) => void, (failureReason: any, pageId: PageId, targetParentPageId?: PageId) => void, (pageId: PageId, targetParentPageId?: PageId) => Promise<PageNavigationNode<PageNavigationData>>>;
+        attachVariationPage: import("@omnia/fx/stores").StoreAction<unknown, (originalPageId: PageId, variationPageId: PageId) => void, (result: PageNavigationNode<PageNavigationData>, originalPageId: PageId, variationPageId: PageId) => void, (failureReason: any, originalPageId: PageId, variationPageId: PageId) => void, (originalPageId: PageId, variationPageId: PageId) => Promise<PageNavigationNode<PageNavigationData>>>;
+        visitedpage: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: ReadNews, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<ReadNews>>;
+        getSitePagesFolderFullUrl: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: string, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<string>>;
+        getPageVersionMetaData: import("@omnia/fx/stores").StoreAction<unknown, (versionId: VersionId) => void, (result: ApprovalMetaData, versionId: VersionId) => void, (failureReason: any, versionId: VersionId) => void, (versionId: VersionId) => Promise<ApprovalMetaData>>;
+    };
+    private updatePageCollectionSelectionsPromise;
+    private handleNewPageAndNode;
+    private getVersionRefCacheKey;
+    private getVersionLoadPromise;
+    private getPageCollectionSelectionFromCache;
+    private updatePageHiddenAndSoftDeleted;
+    private onMergeLayoutCompleted;
+}

package/internal-do-not-import-from-here/fx/stores/PublishingAppInfoStore.d.ts

@@ -0,0 +1,48 @@
+import { Store } from "@omnia/fx/stores";
+import { AppInstanceOutputInfo } from "@omnia/fx-models";
+import { AppRouteService, AppService } from "@omnia/fx/services";
+import { PublishingAppInfoDict } from "../models";
+export declare class PublishingAppInfoStore extends Store {
+    appService: AppService;
+    appRouteService: AppRouteService;
+    private model;
+    private loadInfosPromise;
+    private loadedAppIds;
+    defaultPageCollectionRoutes: import("@omnia/fx/stores").StoreState<{
+        [pubAppId: string]: string;
+    }>;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        allInfos: () => PublishingAppInfoDict;
+        allInfosAsArray: () => import("../models").PublishingAppInfo[];
+        info: (id: string) => import("../models").PublishingAppInfo;
+        defaultPageCollectionRoute: () => {
+            [pubAppId: string]: string;
+        };
+    };
+    setters: {};
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        storeInfo: import("@omnia/fx/stores").StoreMutation<(outputs: Array<AppInstanceOutputInfo>) => void, (outputs: AppInstanceOutputInfo[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        /**
+         *  load all publishing app infos
+         *  @param forceLoadFromServer whether force load info from server
+         *  @return {Promise<boolean>} true - load from server | false - load from cache
+         */
+        ensureLoadInfos: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: any) => void, (failureReason: any) => void, () => Promise<any>>;
+        /**
+         *  load publishing app infos by ids
+         *  @param ids app ids need to load info
+         */
+        ensureLoadInfosByIds: import("@omnia/fx/stores").StoreAction<unknown, (ids: string[]) => void, (result: any, ids: string[]) => void, (failureReason: any, ids: string[]) => void, (ids: Array<string>) => Promise<any>>;
+        getDefaultPageCollectionRoute: import("@omnia/fx/stores").StoreAction<unknown, (publishingAppId: string, routePath?: string) => void, (result: string, publishingAppId: string, routePath?: string) => void, (failureReason: any, publishingAppId: string, routePath?: string) => void, (publishingAppId: string, routePath?: string) => Promise<string>>;
+    };
+}

package/internal-do-not-import-from-here/fx/stores/PublishingRuleStore.d.ts

@@ -0,0 +1,59 @@
+import { NotificationMessage } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { ApprovalRequest, ApprovalRuleData } from "../../models";
+import { ApprovePageInfo, PageId, PublishingRule, PublishingRuleData, SendBackPageInfo } from "../models";
+import { ApprovalData } from "internal/fx/models";
+import { RejectPageInfo } from "../models/publishingrule/RejectPageInfo";
+export declare class PublishingRuleStore extends Store {
+    private publishingRuleService;
+    private omniaCtx;
+    private currentNavigationStore;
+    private pagesStore;
+    private currentPageStore;
+    private variationStore;
+    private permissionService;
+    private fxLoc;
+    private resolvedUser;
+    private rules;
+    private rulePromises;
+    private isHaveApprovalRequest;
+    private isHaveScheduleApprovalRequest;
+    private isHaveSchedule;
+    private isHaveSupportedLanguage;
+    private isMachineTranslated;
+    private isHaveAppAdminPermission;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        getPublishingRules: (pageId: PageId) => Array<PublishingRule>;
+        getScheduleMessege: (pageId: PageId) => NotificationMessage;
+        isPageVersionHaveSchedule: (pageId: PageId) => boolean;
+        isPageVersionHaveApprovalRequest: (pageId: PageId) => boolean;
+        isPageVersionHaveScheduleApprovalRequest: (pageId: PageId) => boolean;
+        isPageAutomaticMachineTranslate: (pageId: PageId) => boolean;
+        onRulesMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<{
+            [pageId: number]: PublishingRule<PublishingRuleData>[];
+        }>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        isPublishingRuleExisted: (pageId: PageId) => boolean;
+        canCancelApproval: (pageId: PageId, approvalData: ApprovalData) => boolean;
+        canApproveOrReject: (pageId: PageId, defaultPageCollectionApprovalData: ApprovalData) => boolean;
+        isEditableApprovalStep: (pageId: PageId) => boolean;
+    };
+    mutations: {
+        updateApprovalData: import("@omnia/fx/stores").StoreMutation<(ruleData: PublishingRule<ApprovalRuleData>) => void, (ruleData: PublishingRule<ApprovalRuleData>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateRules: import("@omnia/fx/stores").StoreMutation<(pageRules: Array<PublishingRule>, pageId: number) => void, (pageRules: PublishingRule<PublishingRuleData>[], pageId: number) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensurePageRules: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId, forceRefresh?: boolean) => void, (result: void, pageId: PageId, forceRefresh?: boolean) => void, (failureReason: any, pageId: PageId, forceRefresh?: boolean) => void, (pageId: PageId, forceRefresh?: boolean) => Promise<void>>;
+        getAllPageRules: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: unknown, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<unknown>>;
+        sendApprovalRequest: import("@omnia/fx/stores").StoreAction<unknown, (request: ApprovalRequest) => void, (result: PublishingRule<ApprovalRuleData>[], request: ApprovalRequest) => void, (failureReason: any, request: ApprovalRequest) => void, (request: ApprovalRequest) => Promise<PublishingRule<ApprovalRuleData>[]>>;
+        cancelApproval: import("@omnia/fx/stores").StoreAction<unknown, (ruleData: PublishingRule<ApprovalRuleData>) => void, (result: PublishingRule<PublishingRuleData>[], ruleData: PublishingRule<ApprovalRuleData>) => void, (failureReason: any, ruleData: PublishingRule<ApprovalRuleData>) => void, (ruleData: PublishingRule<ApprovalRuleData>) => Promise<Array<PublishingRule>>>;
+        approve: import("@omnia/fx/stores").StoreAction<unknown, (approvePageInfo: ApprovePageInfo) => void, (result: PublishingRule<ApprovalRuleData>, approvePageInfo: ApprovePageInfo) => void, (failureReason: any, approvePageInfo: ApprovePageInfo) => void, (approvePageInfo: ApprovePageInfo) => Promise<PublishingRule<ApprovalRuleData>>>;
+        reject: import("@omnia/fx/stores").StoreAction<unknown, (rejectPageInfo: RejectPageInfo) => void, (result: PublishingRule<PublishingRuleData>[], rejectPageInfo: RejectPageInfo) => void, (failureReason: any, rejectPageInfo: RejectPageInfo) => void, (rejectPageInfo: RejectPageInfo) => Promise<Array<PublishingRule>>>;
+        addRule: import("@omnia/fx/stores").StoreAction<unknown, (ruleData: PublishingRuleData, pageId: PageId) => void, (result: PublishingRule<PublishingRuleData>, ruleData: PublishingRuleData, pageId: PageId) => void, (failureReason: any, ruleData: PublishingRuleData, pageId: PageId) => void, (ruleData: PublishingRuleData, pageId: PageId) => Promise<PublishingRule>>;
+        deleteRule: import("@omnia/fx/stores").StoreAction<unknown, (rule: PublishingRule<PublishingRuleData>) => void, (result: PublishingRule<PublishingRuleData>, rule: PublishingRule<PublishingRuleData>) => void, (failureReason: any, rule: PublishingRule<PublishingRuleData>) => void, (rule: PublishingRule) => Promise<PublishingRule>>;
+        updateRules: import("@omnia/fx/stores").StoreAction<unknown, (rule: PublishingRule<PublishingRuleData>) => void, (result: PublishingRule<PublishingRuleData>, rule: PublishingRule<PublishingRuleData>) => void, (failureReason: any, rule: PublishingRule<PublishingRuleData>) => void, (rule: PublishingRule) => Promise<PublishingRule>>;
+        sendBackRules: import("@omnia/fx/stores").StoreAction<unknown, (sendBackPageInfo: SendBackPageInfo) => void, (result: PublishingRule<PublishingRuleData>, sendBackPageInfo: SendBackPageInfo) => void, (failureReason: any, sendBackPageInfo: SendBackPageInfo) => void, (sendBackPageInfo: SendBackPageInfo) => Promise<PublishingRule>>;
+    };
+    private checkPageRules;
+}

package/internal-do-not-import-from-here/fx/stores/TargetingStore.d.ts

@@ -0,0 +1,22 @@
+import { Store } from "@omnia/fx/stores";
+import { EnterprisePropertiesSettings } from "@omnia/fx-sp";
+import { Enums } from "../../core";
+export declare class TargetingStore extends Store {
+    private enterprisePropertyStore;
+    private omniaContext;
+    private targetingPropertyStore;
+    private ensureDataPromise;
+    private ensuredData;
+    private enterprisePropertiesByInternalName;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    getters: {
+        targetingToUser: (targetingFilterProperties: {
+            [property: string]: EnterprisePropertiesSettings;
+        }) => Enums.TargetUser;
+    };
+    actions: {
+        ensureData: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    private buildEnterpriseProperties;
+}

package/internal-do-not-import-from-here/fx/stores/TopicsActivityStore.d.ts

@@ -0,0 +1,60 @@
+import { Store } from "@omnia/fx/stores";
+import { Topic } from "../models";
+import { TopicSubscription } from "../models";
+import { UserTopicActivity, TopicInformation } from "../models";
+import { TopicWithFilter } from "../models";
+import { ActivityFilter } from "../models";
+export type ActivityQueryFilter = Array<TopicWithFilter> | ActivityFilter;
+declare enum PagingType {
+    ActivityFilter = 0,
+    TopicFilter = 1
+}
+export interface IActivitiesPageToken {
+    type: PagingType;
+    filterRep: string;
+}
+export declare class TopicsActivityStore extends Store {
+    private topicActivityService;
+    private subscriptions;
+    private userTopicActivitiesByFilter;
+    private topicInformation;
+    private loadSubscriptionsPromise;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        isSubscribing: (topic: Topic) => boolean;
+        subscriptionByTopic: (topic: Topic) => TopicSubscription;
+        subscriptions: () => Array<TopicSubscription>;
+        /**
+         * Returns information about a topic, if infor has been loaded, else null
+         * */
+        topicInformation: (topic: Topic) => TopicInformation;
+        /**
+         * Get activities by topic and filter, topic and null filter for all on topic
+         * */
+        topicActivities: (filter: ActivityQueryFilter) => Array<UserTopicActivity>;
+    };
+    get mutationEvents(): {
+        onSubscriptionsMutated: (fn: (obj: import("@omnia/fx-models").StateMutation<TopicSubscription[]>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    };
+    actions: {
+        subscribe: import("@omnia/fx/stores").StoreAction<unknown, (topics: Topic[]) => void, (result: void, topics: Topic[]) => void, (failureReason: any, topics: Topic[]) => void, (topics: Array<Topic>) => Promise<void>>;
+        unSubscribe: import("@omnia/fx/stores").StoreAction<unknown, (subscriptionsToUnsubscribe: TopicSubscription[]) => void, (result: void, subscriptionsToUnsubscribe: TopicSubscription[]) => void, (failureReason: any, subscriptionsToUnsubscribe: TopicSubscription[]) => void, (subscriptionsToUnsubscribe: Array<TopicSubscription>) => Promise<void>>;
+        /**
+         * Loads user subscription
+         *
+         * */
+        loadSubscriptions: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        loadTopicActivities: import("@omnia/fx/stores").StoreAction<unknown, (filter: ActivityQueryFilter) => void, (result: IActivitiesPageToken, filter: ActivityQueryFilter) => void, (failureReason: any, filter: ActivityQueryFilter) => void, (filter: ActivityQueryFilter) => Promise<IActivitiesPageToken>>;
+        loadTopicActivitiesNextPage: import("@omnia/fx/stores").StoreAction<unknown, (nextPageToken: IActivitiesPageToken) => void, (result: IActivitiesPageToken, nextPageToken: IActivitiesPageToken) => void, (failureReason: any, nextPageToken: IActivitiesPageToken) => void, (nextPageToken: IActivitiesPageToken) => Promise<IActivitiesPageToken>>;
+        /***
+        * Get topic information for specified topics
+        * Gathers additional information for the topics given, i.e. like displayfriendy information
+        * Note some topic like tag and user does not provide any extra information due to the nature of the topic, this only returns the baseic TopicInformation
+        * **/
+        loadTopicInformation: import("@omnia/fx/stores").StoreAction<unknown, (...args: Topic[]) => void, (result: void, ...args: Topic[]) => void, (failureReason: any, ...args: Topic[]) => void, (...params: Topic[]) => Promise<void>>;
+    };
+    private handleLoadedTopicActivitiesResult;
+    private createTopicIdentifier;
+}
+export {};