@omnia/wcm 7.11.33 → 7.12.2

package/internal-do-not-import-from-here/fx/models/publishingrule/PublishingRule.d.ts

@@ -1,5 +1,5 @@
 import { Identity } from "@omnia/fx-models";
-import { ApprovalData, PageId, SchedulingSettings, VersionId } from "../pages";
+import { ApprovalBypassSettings, ApprovalData, PageId, SchedulingSettings, VersionId } from "../pages";
 export declare enum RuleStatus {
     Unassigned = 0,
     Success = 1,
@@ -27,6 +27,7 @@ export interface PublishingRule<T extends PublishingRuleData = PublishingRuleDat
 }
 export interface ApprovalSettings {
     approvalData: ApprovalData;
+    approvalBypassSettings?: ApprovalBypassSettings;
     enableSendPageEmail: boolean;
     schedulingSettings: SchedulingSettings;
 }

package/internal-do-not-import-from-here/fx/models/publishingsetting/publishingsetting.d.ts

@@ -6,6 +6,7 @@ export interface StatisticProviderSetting {
 export interface CommentsAndLikesSettings {
     disableLikes: boolean;
     disableComments: boolean;
+    disableShare: boolean;
 }
 export interface PublishingSetting {
     id: number;

package/internal-do-not-import-from-here/fx/models/query/ItemQuery.d.ts

@@ -14,7 +14,7 @@ export interface QueryFilter {
     operator: FilterOperator;
     propertyName: string;
     propertyValues: Array<any>;
-    logicalOperator?: FilterLogicalOperator;
+    logicalOperator: FilterLogicalOperator;
     filters?: Array<QueryFilter>;
 }
 export interface QueryOrder {

package/internal-do-not-import-from-here/fx/models/search/PageResultSearchTemplate.d.ts

@@ -0,0 +1,4 @@
+import { CommonSearchTemplateSettings } from "@omnia/workplace/models";
+export interface PageResultSearchTemplateSettings extends CommonSearchTemplateSettings {
+    openInSharePointFullPage?: boolean;
+}

package/internal-do-not-import-from-here/fx/models/search/PageResultSearchTemplate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/internal-do-not-import-from-here/fx/models/search/index.d.ts

@@ -1 +1,2 @@
 export * from "./PageDocument";
+export * from "./PageResultSearchTemplate";

package/internal-do-not-import-from-here/fx/models/search/index.js

@@ -2,3 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./PageDocument"), exports);
+tslib_1.__exportStar(require("./PageResultSearchTemplate"), exports);

package/internal-do-not-import-from-here/fx/routing/WcmRouter.d.ts

@@ -1,4 +1,4 @@
-import { DefaultVariationPage, NavigationData, NavigationNode, PageNavigationData, PageNavigationNode, VariationId } from "../models";
+import { CurrentPageStatus, DefaultVariationPage, NavigationData, NavigationNode, PageNavigationData, PageNavigationNode, VariationId } from "../models";
 export declare class WcmRouter {
     private currentNavigationStore;
     private currentPageStore;
@@ -10,23 +10,32 @@ export declare class WcmRouter {
     private publishingAppInfoStore;
     private userTargetingStore;
     private multilingualStore;
+    private manifestService;
     private isVariationSwitch;
+    isInFullPageExperience: boolean;
     private currentNavigatedState;
+    private navigationRequestId;
+    private currentNavigatedRequestId;
+    private loadedNavigationState;
     private loadTreeForPathPromises;
+    pendingPageFailureReason: string | null;
     private initState;
     constructor();
     private isInWcmContext;
     private handleNotFoundNavigationNode;
+    private ensurePageRenderer;
+    private removePageRenderer;
     private removeAnchorWhenPageNavigating;
     private isVariationDebugEnabled;
     private logVariationDebug;
     private getReplayTargetVariationId;
     private getDefaultRoute;
     private loadTreeForPath;
-    navigate<T extends NavigationNode<NavigationData>>(to: T, targetVariationId?: any, forceToNewNavigationState?: boolean): Promise<T>;
-    navigateWithVariationTargeting<T extends NavigationNode<NavigationData>>(to: T): Promise<T>;
-    navigateFromExternalApp<T extends NavigationNode<NavigationData>>(to: T, targetVariationId?: any, openEditor?: boolean): void;
+    navigate<T extends NavigationNode<NavigationData>>(to: T, targetVariationId?: VariationId, forceToNewNavigationState?: boolean, requestId?: number): Promise<T>;
+    navigateWithVariationTargeting<T extends NavigationNode<NavigationData>>(to: T, requestId?: number): Promise<T>;
+    navigateFromExternalApp<T extends NavigationNode<NavigationData>>(to: T, targetVariationId?: VariationId, openEditor?: boolean): void;
     private buildRelativePath;
+    private routePathHasVariationSegment;
     private getTargetingVariation;
     onDisposing(): void;
     private executeScrollingIfNeeded;
@@ -38,7 +47,11 @@ export declare class WcmRouter {
      * */
     private createNavigationStateForNode;
     private tryParseNumber;
-    private getPageTitle;
+    static getPageFailureStatus(reason: unknown): CurrentPageStatus;
+    private setPageFailure;
+    private getBusinessProfileTitle;
+    private resetDocumentTitle;
+    private updateDocumentTitle;
     getPageState(pageNavigationNode: PageNavigationNode<PageNavigationData>, targetVariationId?: VariationId, allowDraftVersion?: boolean): DefaultVariationPage;
     private getUsingVariationSegment;
 }

package/internal-do-not-import-from-here/fx/services/OmniaSearchPageService.d.ts

@@ -7,7 +7,14 @@ export declare class OmniaSearchPageService {
     omniaSearchService: OmniaSearchService;
     constructor();
     queryBatchPages: (searchQueryRequest: PagedBatchSearchRequest, cancelRequest?: (cancelToken: any) => void) => Promise<IPagedSearchResult<PageDocument>[]>;
-    getExtendedInformationPageQueryData: (pageIds: Array<PageId>) => Promise<ExtendedInformationPageQueryData>;
+    /**
+     * @param pageIdsForMyLikes Subset of pageIds whose like the current user's own reaction should
+     * be fetched for. Only include IDs from queries that had includeMyLikes==true; the server skips
+     * the social lookup when this list is empty. Part of the dedupe key.
+     */
+    getExtendedInformationPageQueryData: (pageIds: Array<PageId>, pageIdsForMyLikes: {
+        [pageId: number]: string;
+    }) => Promise<ExtendedInformationPageQueryData>;
     triggerReindexContentOmniaSearchPublishingApp: () => Promise<string>;
     triggerReindexContentOmniaSearchTenant: (syncType: SyncOmniaSearchType) => Promise<string>;
     getReindexContentOmniaSearchStatus: (resourceId: string) => Promise<ReindexContentOmniaSearch>;

package/internal-do-not-import-from-here/fx/services/PageService.d.ts

@@ -14,7 +14,8 @@ export declare class PageService {
     static obsoleteSetWCMApp(appId: GuidValue): void;
     private readonly baseUrl;
     private readonly reusablePageBaseUrl;
-    createVariationPage: <T extends PageData>(pageData: T, originalPageId: PageId, variationId: VariationId) => Promise<CreatedPageInfo<T>>;
+    private initHttpRequestParams;
+    createVariationPage: <T extends PageData>(pageData: T, originalPageId: PageId, variationId: VariationId, targetPublishingAppId?: GuidValue) => Promise<CreatedPageInfo<T>>;
     updatePagePermissions: (pageId: PageId, variationId?: VariationId) => Promise<void>;
     createWithNavigation: <T extends PageData>(creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => Promise<CreatedPageWithNavigationInfo<T>>;
     move: <T extends NavigationNode<NavigationData>>(nodeToMove: T, newPosition: NavigationPosition) => Promise<MovePagesResult>;
@@ -68,20 +69,21 @@ export declare class PageService {
      */
     attachVariationPage: (originalPageId: PageId, variationPageId: PageId, variationId?: VariationId, targetPublishingAppId?: string) => Promise<VariationPage>;
     getPagesByIds: (pageIds: Array<PageId>) => Promise<PageIdToPageMap>;
-    checkIn: <T extends PageData>(versionToCheckIn: CheckedOutVersionPageData<T>) => Promise<VersionedPageData<T>>;
-    takeOverCheckedoutPage: <T extends PageData>(versionToTakeOver: CheckedOutVersionPageData<T>) => Promise<CheckedOutVersionPageData<T>>;
+    checkIn: <T extends PageData>(versionToCheckIn: CheckedOutVersionPageData<T>, targetPublishingAppId?: GuidValue) => Promise<VersionedPageData<T>>;
+    takeOverCheckedoutPage: <T extends PageData>(versionToTakeOver: CheckedOutVersionPageData<T>, targetPublishingApp?: GuidValue) => Promise<CheckedOutVersionPageData<T>>;
     /**
      * Saves the data for a checkedoutversion
      *
      * (Checkedoutversiosn may change over time, other version types are immutable)
      * */
-    saveState: <T extends PageData>(versionToCheckIn: CheckedOutVersionPageData<T>) => Promise<CheckedOutVersionPageData<T>>;
-    checkOut: (pageId: PageId) => Promise<CheckedOutVersionPageData<PageData>>;
-    undoCheckout: <T extends PageData>(checkedOutVersionToUncheckOut: CheckedOutVersionPageData<T>) => Promise<VersionedPageData<T>>;
+    saveState: <T extends PageData>(versionToCheckIn: CheckedOutVersionPageData<T>, targetPublishingAppId?: GuidValue) => Promise<CheckedOutVersionPageData<T>>;
+    checkOut: (pageId: PageId, targetPublishingAppId?: GuidValue) => Promise<CheckedOutVersionPageData<PageData>>;
+    undoCheckout: <T extends PageData>(checkedOutVersionToUncheckOut: CheckedOutVersionPageData<T>, targetPublishingAppId?: GuidValue) => Promise<VersionedPageData<T>>;
     getCheckedOutVersion: (pageId: PageId) => Promise<CheckedOutVersionPageData<PageData>>;
     publish: <T extends PageData>(versionToPublish: VersionedPageData<T>, targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => Promise<PublishedVersionPageData<T>>;
     unPublish: <T extends PageData>(versionToUnPublish: PublishedVersionPageData<T>) => Promise<VersionedPageData<T>>;
     getPublishedVersion: (pageId: PageId, targetPublishingAppId?: string) => Promise<PublishedVersionPageData<PageData>>;
+    private getInflightMergeLayoutMap;
     /**
      * Merges the source layout values into target layout
      */

package/internal-do-not-import-from-here/fx/shared/OmniaFullPageHelper.d.ts

@@ -0,0 +1 @@
+export declare function isOnOmniaFullPageSitePage(): boolean;

package/internal-do-not-import-from-here/fx/shared/PageRollupStoreHelper.d.ts

@@ -56,6 +56,7 @@ declare class InternalPageRollupStoreHelper {
     private cancelBatchQueryTokens;
     private executingBatchQuery;
     private hasNewBatchQueryNeedToExecute;
+    private currentBatchRunToken;
     private pagerollupOutsideWCMLayout;
     private executingQueriesStatus;
     private excludeCountry;
@@ -102,6 +103,25 @@ declare class InternalPageRollupStoreHelper {
     private populateNavigationPathTargetingVariationIds;
     private generateVariationIdFilter;
     buildQuery(block: BlockPageRollupInstanceExtends, uiQueryFilters: QueryFilter[]): Promise<PageQuery>;
+    /**
+     * The query's internal names, with the comment/reaction count properties guaranteed present
+     * whenever the block shows likes/comments.
+     *
+     * They are normally pushed into `selectProperties` by each view's settings component, but only
+     * inside `if (viewSettings.showLikesComments)` and only when that path runs — so a block whose
+     * settings were saved before the toggle was turned on keeps a `selectProperties` without them.
+     * The counts then never make it into the request: on the search path
+     * `OmniaSearchQueryHelper.getRetrieveProperties` maps internal names to `commentCount` /
+     * `reactionCount` (via OmniaSearchQueryUtils), so a missing internal name means a missing
+     * `retrieveProperties` entry; the counts come back absent and
+     * `PageRollupStore.generatePageSocialCountingAndPageStatisticsColumn` zeroes them permanently.
+     *
+     * Deriving them here rather than trusting saved settings fixes both transports at once — the
+     * same list becomes `BatchQueryPages.InternalNames` for the batch query and the source of
+     * `retrieveProperties` for multiplesearch. `getPagesDetails` (the dialog path) already hardcodes
+     * both, so the two stay consistent.
+     */
+    private ensureSocialCountInternalNames;
     getPagesDetails(pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit?: number, reloadData?: boolean): Promise<PageDialogData>;
     getPagesDetailsMetric(blockInstance: BlockPageRollupInstanceExtends, settings: PageRollupBlockSettings, uiQueryFilters: QueryFilter[], orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): Promise<void>;
     generateBatchQuery(blockPageRollupInstance: BlockPageRollupInstanceExtends): Promise<BatchQueryPages>;
@@ -114,6 +134,7 @@ declare class InternalPageRollupStoreHelper {
     private validateSetting;
     private buildUserTargetingQuery;
     private getInstancesToBatchQuery;
+    private ensureCurrentPageReady;
     private ensureInitialData;
     private get pageBlockPropertyStore();
     renewPageBlockPropertyStore(): void;
@@ -121,6 +142,7 @@ declare class InternalPageRollupStoreHelper {
     private hasVariationQueryFilter;
     private hasVariationValueQueryFilter;
     private runBatchQueryForInstances;
+    private prefetchClientCachePaint;
     private executeIndexedDB;
     private runIsolatedBatchQueryForInstances;
     private buildUIFiltersForBlockInstance;
@@ -223,7 +245,7 @@ export declare class BatchQueryRegistration {
     getNextPagingData(): Promise<number>;
     private noNextPaging;
     private loadCurrentPageData;
-    generateBatchQuery(includeAZPagingFilter?: boolean): Promise<BatchQueryPages>;
+    generateBatchQuery(): Promise<BatchQueryPages>;
     getBlockPageRollupInstance(): BlockPageRollupInstanceExtends;
     get orderBy(): QueryOrder[];
     get pagingNumber(): number;

package/internal-do-not-import-from-here/fx/shared/PageSearchHelper.d.ts

@@ -13,12 +13,18 @@ export declare class PageSearchHelper {
     featureStore: FeatureStore;
     pageRollupStore: PageRollupStore;
     omniaCtx: OmniaContext;
+    private commentLikeStore;
     private richTextPropertyInternalNames;
     private static outOfScopeOmniaSearchProperties;
+    private socialCountsDb;
+    private socialCountsDbOpenPromise;
+    private static lastPurgeAt;
+    private static readonly PURGE_INTERVAL_MS;
     queryBatchPages(queries: BatchQueryPages[], cancelRequest?: (cancelToken: any) => void): Promise<BatchQueryPagesResult>;
     private getOutOfScopeOmniaSearchQueries;
     private hasOutOfScopeOmniaSearchPropertiesInFilter;
     private ensureQueryPageRollupInOmniaSearch;
+    private getExtendedInfoWithStoreLikes;
     private trimDuplicateBatchResults;
     private processPagesDetailData;
     private getUniquePageDetails;
@@ -26,4 +32,10 @@ export declare class PageSearchHelper {
     private replaceTokenWithDnsForRichTextProperties;
     private getRichTextPropertyInternalNames;
     private replaceTokenWithDns;
+    private openSocialCountsDb;
+    private purgeExpiredSocialCounts;
+    private getSocialCountsFromDB;
+    private isSocialCountExpired;
+    private isNewerSocialTimestamp;
+    updateSocialCountsFromCommentLikeStore(topicId: string, comments: any[] | null, likes: any[] | null): void;
 }

package/internal-do-not-import-from-here/fx/shared/PlaceholderImage.d.ts

@@ -0,0 +1 @@
+export declare function getPageRollupPlaceholderImageUrl(type: "page" | "event"): string;

package/internal-do-not-import-from-here/fx/shared/index.d.ts

@@ -1,7 +1,8 @@
-export * from "./PageRollupStoreHelper";
+export * from "./EnterpriseGlossaryHelper";
+export * from "./OmniaFullPageHelper";
+export * from "./OmniaSearchCategoryQueryHelper";
+export * from "./OmniaSearchQueryHelper";
 export * from "./OmniaSearchQueryUtils";
+export * from "./PageRollupStoreHelper";
 export * from "./PageSearchHelper";
-export * from "./OmniaSearchQueryHelper";
-export * from "./OmniaSearchCategoryQueryHelper";
 export * from "./PickedPageHelper";
-export * from "./EnterpriseGlossaryHelper";

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

@@ -13,7 +13,7 @@ export declare class ActivityFeedStore extends Store {
      * Implementation of mutations
      */
     mutations: {
-        setThemeStyling: import("@omnia/fx/stores").StoreMutation<(themeStyling: ThemeStyling, customStyling: boolean) => void, (themeStyling: ThemeStyling, customStyling: boolean) => import("@omnia/fx-models/Messaging").IMessageBusSubscriptionHandler>;
+        setThemeStyling: import("@omnia/fx/stores").StoreMutation<(themeStyling: ThemeStyling, customStyling: boolean) => void, (themeStyling: ThemeStyling, customStyling: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {};
 }

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

@@ -0,0 +1,289 @@
+import { Layout } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { IPageVersion, Page, PageData, PageId, VersionedPageData, VersionId, VersionReference } from "../models";
+export interface IBaseCurrentPageState {
+    /**
+     * 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 BaseCurrentPageStore extends Store {
+    private pageService;
+    private pagesStore;
+    private securityService;
+    private permissionService;
+    private NavigationStore;
+    private omniaCtx;
+    private subscriptionHandler;
+    private dynamicStateStore;
+    private variationStore;
+    private editMode;
+    private current;
+    private completedMovePageTrackingId;
+    private appInstanceContextHandler;
+    private pageIdSecurityContextHandler;
+    private pageLoadRequestId;
+    /**
+     * Indicates whether to use page.publishingAppId.
+     * - false (default in CurrentPageStore): Return null
+     * - true (in EditPageCurrentPageStore): Use page.publishingAppId - user explicitly selected this page
+     */
+    protected usePagePublishingAppId: boolean;
+    onActivated(): void;
+    private setupPageSecurityTracking;
+    protected ensureOwnedSecurityContextHandlers(): void;
+    protected setOwnedSecurityContext(appInstanceId: string, pageId: PageId): void;
+    protected getRouteAppInstanceId(): string;
+    onDisposing(): void;
+    /**
+     * Gets the target publishing app ID based on context.
+     * - Edit dialog: Uses page.publishingAppId
+     * - Main app: Returns null
+     */
+    private get targetPublishingAppId();
+    protected get baseGetters(): {
+        /**
+        * The state of the current page
+        *
+        * */
+        readonly state: IBaseCurrentPageState;
+    };
+    get getters(): {
+        /**
+        * The state of the current page
+        *
+        * */
+        readonly state: IBaseCurrentPageState;
+    };
+    /**
+     * Implementation of mutations
+     */
+    protected baseMutations: {
+        /**
+         * 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: IBaseCurrentPageState) => void, (currentPage: IBaseCurrentPageState) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    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: IBaseCurrentPageState) => void, (currentPage: IBaseCurrentPageState) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     *
+     * You can listen for onDispatching, onDispatched and on failure for all actions
+     */
+    protected baseActions: {
+        /**
+         * 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, isCurrentNavigation?: () => boolean) => void, (result: {
+            pageOveridden: PageId;
+        }, versionRef: VersionReference, isCurrentNavigation?: () => boolean) => void, (failureReason: any, versionRef: VersionReference, isCurrentNavigation?: () => boolean) => void, (versionRef: VersionReference, isCurrentNavigation?: () => boolean) => 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, isCurrentNavigation?: () => boolean) => void, (result: void, pageId: PageId, isCurrentNavigation?: () => boolean) => void, (failureReason: any, pageId: PageId, isCurrentNavigation?: () => boolean) => void, (pageId: PageId, isCurrentNavigation?: () => boolean) => 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, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (result: {
+            publishedVersionId: VersionId;
+        }, targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (failureReason: any, targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        publishWithoutNavigating: import("@omnia/fx/stores").StoreAction<unknown, (versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (result: {
+            publishedVersionId: VersionId;
+        }, versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (failureReason: any, versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        reloadPublishedVersion: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: {
+            publishedVersionId: VersionId;
+        }) => void, (failureReason: any) => void, () => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        ensureMovePageTracking: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    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, isCurrentNavigation?: () => boolean) => void, (result: {
+            pageOveridden: PageId;
+        }, versionRef: VersionReference, isCurrentNavigation?: () => boolean) => void, (failureReason: any, versionRef: VersionReference, isCurrentNavigation?: () => boolean) => void, (versionRef: VersionReference, isCurrentNavigation?: () => boolean) => 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, isCurrentNavigation?: () => boolean) => void, (result: void, pageId: PageId, isCurrentNavigation?: () => boolean) => void, (failureReason: any, pageId: PageId, isCurrentNavigation?: () => boolean) => void, (pageId: PageId, isCurrentNavigation?: () => boolean) => 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, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (result: {
+            publishedVersionId: VersionId;
+        }, targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (failureReason: any, targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => void, (targetPublishingAppId?: string, withoutNotification?: boolean, sendPreviewEmail?: boolean) => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        publishWithoutNavigating: import("@omnia/fx/stores").StoreAction<unknown, (versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (result: {
+            publishedVersionId: VersionId;
+        }, versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (failureReason: any, versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => void, (versionPageData: VersionedPageData<PageData>, targetPublishingAppId?: string) => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        reloadPublishedVersion: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: {
+            publishedVersionId: VersionId;
+        }) => void, (failureReason: any) => void, () => Promise<{
+            publishedVersionId: VersionId;
+        }>>;
+        ensureMovePageTracking: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    private onPublishedVersionUpdated;
+    private createCurrentPageState;
+    private clearTransientApprovalBypassHistory;
+    /**
+     * 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/CurrentNavigationStore.d.ts

@@ -47,11 +47,11 @@ export declare class CurrentNavigationStore extends Store {
      */
     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>>;
+        ensureTreeForNode: import("@omnia/fx/stores").StoreAction<unknown, (node: NavigationNode<NavigationData>, isCurrentNavigation?: () => boolean) => void, (result: void, node: NavigationNode<NavigationData>, isCurrentNavigation?: () => boolean) => void, (failureReason: any, node: NavigationNode<NavigationData>, isCurrentNavigation?: () => boolean) => void, (node: NavigationNode<NavigationData>, isCurrentNavigation?: () => boolean) => Promise<void>>;
+        ensureTreeForPath: import("@omnia/fx/stores").StoreAction<unknown, (path: string, isCurrentNavigation?: () => boolean) => void, (result: NavigationNode<NavigationData>, path: string, isCurrentNavigation?: () => boolean) => void, (failureReason: any, path: string, isCurrentNavigation?: () => boolean) => void, (path: string, isCurrentNavigation?: () => boolean) => Promise<NavigationNode<NavigationData>>>;
         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 getActiveNodes;
     private mutateNodeState;
 }