@omnia/wcm 8.0.0-vnext → 8.0.2-vnext

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

@@ -0,0 +1,48 @@
+import { Store } from "@omnia/fx/stores";
+import { CurrentPageStore } from "../stores/CurrentPageStore";
+import { EventDetail, PageId, Participant } from "@omnia/wcm/models";
+import { CalendarService, EventService, ParticipantService } from "../services";
+export declare const CURRENT_DATE: Date;
+export declare class CurrentEventStore extends Store {
+    participantService: ParticipantService;
+    eventService: EventService;
+    private permissionService;
+    calendarService: CalendarService;
+    currentPageStore: CurrentPageStore;
+    private events;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        events: () => Array<EventDetail>;
+        eventDetail: () => Promise<EventDetail>;
+        canConnectToOutlook: () => Promise<boolean>;
+        isValidToEditParticipant: () => Promise<boolean>;
+        isValidToSignUp: () => Promise<boolean>;
+        isValidToReserve: () => Promise<boolean>;
+        isValidToCancel: () => Promise<boolean>;
+        hasSignedUpForEvent: (loginNameOrEmail: string) => Promise<boolean>;
+        enableStandbyListPropValue: () => boolean;
+    };
+    actions: {
+        ensureStoredEventDetail: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: EventDetail) => void, (failureReason: any) => void, () => Promise<EventDetail>>;
+        ensureEvent: import("@omnia/fx/stores").StoreAction<unknown, (eventDetail: EventDetail) => void, (result: EventDetail, eventDetail: EventDetail) => void, (failureReason: any, eventDetail: EventDetail) => void, (eventDetail: EventDetail) => Promise<EventDetail>>;
+        deleteEvent: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: EventDetail, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<EventDetail>>;
+        updateRegisteredCapacity: import("@omnia/fx/stores").StoreAction<unknown, (registeredCapacity: number) => void, (result: EventDetail, registeredCapacity: number) => void, (failureReason: any, registeredCapacity: number) => void, (registeredCapacity: number) => Promise<EventDetail>>;
+        addOrUpdatePersonalOutlookEvent: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: EventDetail) => void, (failureReason: any) => void, () => Promise<EventDetail>>;
+        addOrUpdateParticipant: import("@omnia/fx/stores").StoreAction<unknown, (participant: Participant) => void, (result: Participant, participant: Participant) => void, (failureReason: any, participant: Participant) => void, (participant: Participant) => Promise<Participant>>;
+        deleteParticipant: import("@omnia/fx/stores").StoreAction<unknown, (participant: Participant) => void, (result: Participant, participant: Participant) => void, (failureReason: any, participant: Participant) => void, (participant: Participant) => Promise<Participant>>;
+        moveParticipantToStandbyList: import("@omnia/fx/stores").StoreAction<unknown, (participant: Participant) => void, (result: Participant, participant: Participant) => void, (failureReason: any, participant: Participant) => void, (participant: Participant) => Promise<Participant>>;
+        moveParticipantToOfficialList: import("@omnia/fx/stores").StoreAction<unknown, (participant: Participant) => void, (result: Participant, participant: Participant) => void, (failureReason: any, participant: Participant) => void, (participant: Participant) => Promise<Participant>>;
+    };
+    /**
+     * Private Methods
+     */
+    private canConnectToOutlookContent;
+    private isValidToEditParticipantContent;
+    private isValidToSignUpContent;
+    private isValidToReserveContent;
+    private isValidToCancelContent;
+    private hasSignedUpForEventContent;
+    private updateEventData;
+    private addOrUpdateParticipantData;
+}

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

@@ -0,0 +1,54 @@
+import { OmniaContext } from "@omnia/fx";
+import { Future, IMessageBusSubscriptionHandler } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { CurrentNavigationStatus, NavigationData, NavigationNode, NodeState, PageCollectionNavigationData, PageCollectionNavigationNode } from "../models";
+import { NavigationService } from "../services/NavigationService";
+import { NavigationStore } from "./NavigationStore";
+export declare class CurrentNavigationStore extends Store {
+    navigationStore: NavigationStore;
+    omniaContext: OmniaContext;
+    navigationService: NavigationService;
+    private readyPromise;
+    private nodeState;
+    private activeNodes;
+    private status;
+    private ensureLoadUnavailableChildrenPromises;
+    private subscriptionHandler;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        /**
+         * Get the children for a given node, null for root
+         */
+        getChildren: (node: NavigationNode<NavigationData>) => Array<NavigationNode<NavigationData>>;
+        getNodeState: (node: NavigationNode<NavigationData>) => NodeState;
+        isActive: (node: NavigationNode<NavigationData>) => boolean;
+        activePageCollectionNode: () => PageCollectionNavigationNode<PageCollectionNavigationData>;
+        selectedNode: () => NavigationNode<NavigationData>;
+        isSelected: (node: NavigationNode<NavigationData>) => boolean;
+        activeNodes: () => Array<NavigationNode<NavigationData>>;
+        isLoadingChildren: (node: NavigationNode<NavigationData>) => boolean;
+        onActiveNodesMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<NavigationNode<NavigationData>[]>) => void) => IMessageBusSubscriptionHandler;
+        status: () => CurrentNavigationStatus;
+    };
+    setter: {};
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        expanded: import("@omnia/fx/stores").StoreMutation<(node: NavigationNode<NavigationData>, isExpanded: boolean) => void, (node: NavigationNode<NavigationData>, isExpanded: boolean) => IMessageBusSubscriptionHandler>;
+        resetExpandedState: import("@omnia/fx/stores").StoreMutation<() => void, () => IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        ensureReady: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Future<void>>;
+        ensureTreeForNode: 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>>;
+        ensureTreeForPath: import("@omnia/fx/stores").StoreAction<unknown, (path: string) => void, (result: void, path: string) => void, (failureReason: any, path: string) => void, (path: string) => Promise<void>>;
+        expand: 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 setStatus;
+    private setActiveNodes;
+    private mutateNodeState;
+}

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

@@ -0,0 +1,159 @@
+import { Store } from "@omnia/fx/stores";
+import { Page, VersionReference, PageId, VersionId, IPageVersion } from "../models";
+import { Layout } from "@omnia/fx-models";
+export interface ICurrentPageState {
+    /**
+     * Reference to the current page
+     * */
+    readonly currentPage: Page;
+    /**
+     * Indicates if the current state is for editmode or not
+     * True - In editor
+     * False - Read mode
+     * */
+    readonly editMode: boolean;
+    /**
+     * The current version of the currentPage
+     * */
+    readonly currentVersion: IPageVersion;
+    /**
+    * The version data of the current page parent
+    * This relates to currentVersion.pageData.layoutData.parentLayoutPageId and takes into account rules revolving checkout, publish, undocheckout, editmode etc.
+    * if the current version does not have a parentLayoutPageId this version data will be null
+    * */
+    readonly parentLayout?: IPageVersion;
+    readonly externalParentLayout?: Layout;
+}
+export declare class CurrentPageStore extends Store {
+    private pageService;
+    private pagesStore;
+    private securityService;
+    private permissionService;
+    private NavigationStore;
+    private omniaCtx;
+    private subscriptionHandler;
+    private dynamicStateStore;
+    private editMode;
+    private current;
+    onActivated(): void;
+    private setupPageSecurityTracking;
+    onDisposing(): void;
+    get getters(): {
+        /**
+        * The state of the current page
+        *
+        * */
+        readonly state: ICurrentPageState;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        /**
+         * Called when the current sate needs to be updated, e.g. a version or page which the current state depend upon changes
+         * */
+        addOrUpdateCurrentPage: import("@omnia/fx/stores").StoreMutation<(currentPage: ICurrentPageState) => void, (currentPage: ICurrentPageState) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     *
+     * You can listen for onDispatching, onDispatched and on failure for all actions
+     */
+    actions: {
+        /**
+         * Changes which page the current page inherites properties from
+         * pageToInheritFrom = null, stop inheriting else the page to inherit from
+         * */
+        setPropertyInheriteance: import("@omnia/fx/stores").StoreAction<unknown, (pageToInheritFrom?: PageId, namesOfPropertiesToInherit?: string[]) => void, (result: void, pageToInheritFrom?: PageId, namesOfPropertiesToInherit?: string[]) => void, (failureReason: any, pageToInheritFrom?: PageId, namesOfPropertiesToInherit?: string[]) => void, (pageToInheritFrom?: PageId, namesOfPropertiesToInherit?: Array<string>) => Promise<void>>;
+        /**
+         *
+         * Specifies if editmode is desired or not.
+         * This influences which version of the page is selected, i.e. latest draft,published or checkedout version
+         *
+         * (You can listen for changes on this action)
+         *
+         * */
+        setEditMode: import("@omnia/fx/stores").StoreAction<unknown, (editMode: boolean) => void, (result: void, editMode: boolean) => void, (failureReason: any, editMode: boolean) => void, (editMode: boolean) => Promise<void>>;
+        /**
+         * This will swap the current page state to match the version specified
+         * This will not take into account any rules regardning version selection based on editmode etc, the specified version is enforced
+         *
+         * This override is valid until a new current page is set using setCurrentPage
+         *
+         * The caller of this is responsible of reseting to current page id (which is returned in the promise) or in another way laod the correct page id using setCurrentPage when the page should no longer be overridden
+         *
+         */
+        overrideVersionToUse: import("@omnia/fx/stores").StoreAction<unknown, (versionRef: VersionReference) => void, (result: {
+            pageOveridden: PageId;
+        }, versionRef: VersionReference) => void, (failureReason: any, versionRef: VersionReference) => void, (versionRef: VersionReference) => Promise<{
+            pageOveridden: PageId;
+        }>>;
+        /**
+         * This updates the current page being used.
+         * Any overidden version is removed.
+         * A state is prepared in relation to rules involving editmode,published,draftversion,checkedout version etc
+         *
+         * (You can listen for changes on this action, i.e. new page etc)
+         *
+         * */
+        setCurrentPage: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: void, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<void>>;
+        /**
+         * CheckOut the current page, when the promise is resolved the
+         * getters.currentVersion will hold the checkedout version
+         * */
+        checkOutPage: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: {
+            checkedoutVersionId: VersionId;
+        }) => void, (failureReason: any) => void, () => Promise<{
+            checkedoutVersionId: VersionId;
+        }>>;
+        /**
+         * The current user takes over the currently checkedout version
+         *
+         * (Only allowed if the current version is checked out)
+         * */
+        takeOverCheckedoutPage: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        /**
+        * Undo current checkOut of the current page
+        *
+        * * */
+        undoCheckout: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        /**
+         * Check in if the current version is checked out
+         * */
+        checkIn: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: {
+            checkedInVersion: VersionId;
+        }) => void, (failureReason: any) => void, () => Promise<{
+            checkedInVersion: VersionId;
+        }>>;
+        /**
+         * Saves the state of the checkedout version
+         *
+         * (Only checkedout versions can be saved, already existing versions are immutable)
+         *
+         */
+        saveState: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+        publish: import("@omnia/fx/stores").StoreAction<unknown, (targetPublishingAppId?: string) => void, (result: {
+            publishedVersionId: VersionId;
+        }, targetPublishingAppId?: string) => void, (failureReason: any, targetPublishingAppId?: string) => void, (targetPublishingAppId?: string) => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        reloadPublishedVersion: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: {
+            publishedVersionId: VersionId;
+        }) => void, (failureReason: any) => void, () => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+    };
+    private onPublishedVersionUpdated;
+    private createCurrentPageState;
+    /**
+     * Temporary solution until we handle this serverside by adding the info in versionrefs to be able to do this using hard caching
+     */
+    private getInheritedEnterprisepropertiesVersion;
+    private isCurrentVersion;
+    private createVersionRefForVersion;
+    private getPageFromStore;
+    private getPageVersionByRules;
+    private ensureCalculatedProperties;
+    private resetState;
+    private releaseDynamicState;
+}

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

@@ -0,0 +1,16 @@
+export default class IndexedDB {
+    private dbName;
+    private dbVersion;
+    private request;
+    private db;
+    private objName;
+    openDB(onsuccess: any, onerror: any, onupgradeneeded: any, objName: any, keyPath: any, objData: any): Promise<void>;
+    get<T>(id: any, valuePath: any): Promise<T>;
+    set(objData: any): Promise<unknown>;
+    remove(id: any): Promise<unknown>;
+    closeDB(): void;
+    /**
+    * check whether indexedDB is supported by the current browser
+    */
+    static canUse(): boolean;
+}

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

@@ -0,0 +1,24 @@
+import { OmniaContext } from "@omnia/fx";
+import { AppStore, MultilingualStore, Store } from "@omnia/fx/stores";
+import { DocumentLibraryInfo, LinkPickerRegistration } from "../models";
+export declare class LinkPickerStore extends Store {
+    private currentProviders;
+    omniaContext: OmniaContext;
+    appStore: AppStore;
+    multilingualStore: MultilingualStore;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        currentProvider: () => Array<LinkPickerRegistration>;
+    };
+    get mutationLinkPickerProviders(): {
+        onSubscriptionsMutated: (fn: (obj: import("@omnia/fx-models").StateMutation<LinkPickerRegistration[]>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    };
+    mutations: {
+        ensureAddProvider: import("@omnia/fx/stores").StoreMutation<(provider: LinkPickerRegistration) => void, (provider: LinkPickerRegistration) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        ensureRemoveProvider: import("@omnia/fx/stores").StoreMutation<(provider: LinkPickerRegistration) => void, (provider: LinkPickerRegistration) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensureLoadCurrentDocumentLibraryUrl: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: DocumentLibraryInfo) => void, (failureReason: any) => void, () => Promise<DocumentLibraryInfo>>;
+    };
+}

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

@@ -0,0 +1,75 @@
+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;
+        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,122 @@
+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 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 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) => void, (result: void, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => void, (failureReason: any, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => void, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => Promise<void>>;
+        navigateWithVariationTargeting: import("@omnia/fx/stores").StoreAction<unknown, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => void, (result: PageNavigationNode<PageNavigationData>, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => void, (failureReason: any, node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => void, (node: PageNavigationNode<PageNavigationData>, pageId: number, pageUrl: string, openInNewTab?: unknown, openInEditor?: unknown) => 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[], allApps?: boolean) => void, (result: void, publishingAppIds: string[], allApps?: boolean) => void, (failureReason: any, publishingAppIds: string[], allApps?: boolean) => void, (publishingAppIds: string[], allApps?: 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>>;
+        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>>;
+    };
+    /**
+     * Find page and page variation in specific node
+     * @param node
+     * @param pageId
+     */
+    private findPageInNode;
+    private getPageTypeLoadPromise;
+    private ensureLoadPageTypePromise;
+    private sortPagesByNavigation;
+    private mapPageTypeSelection;
+}
+export {};