@omnia/wcm 8.0.1-dev → 8.0.2-dev

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

@@ -0,0 +1,40 @@
+import { Store } from "@omnia/fx/stores";
+import { AppInstanceOutputInfo } from "@omnia/fx-models";
+import { AppService } from "@omnia/fx/services";
+import { PublishingAppInfoDict } from "../models";
+export declare class AppInfoStore extends Store {
+    appService: AppService;
+    private model;
+    private loadInfosPromise;
+    private loadedAppIds;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        allInfos: () => PublishingAppInfoDict;
+        allInfosAsArray: () => import("../models").PublishingAppInfo[];
+        info: (id: string) => import("../models").PublishingAppInfo;
+    };
+    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>>;
+    };
+}

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

@@ -0,0 +1,23 @@
+import { Store } from "@omnia/fx/stores";
+import { BreadcrumbExtendedNode, NavigationData, NavigationNode } from "../models";
+export declare class BreadcrumbStore extends Store {
+    private variationStore;
+    private navigationStore;
+    private omniaContext;
+    private extendedNodes;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    getters: {
+        extendedNodes: () => BreadcrumbExtendedNode[];
+        defaultPageCollectionNavigationNode: () => NavigationNode<NavigationData>;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        updateExtendedNodes: import("@omnia/fx/stores").StoreMutation<(nodes: Array<BreadcrumbExtendedNode>) => void, (nodes: BreadcrumbExtendedNode[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        currentNodeCallback: import("@omnia/fx/stores").StoreMutation<(node: NavigationNode<NavigationData>) => void, (node: NavigationNode<NavigationData>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {};
+    private getDefaultRoute;
+}

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

@@ -0,0 +1,13 @@
+import { Store } from "@omnia/fx/stores";
+import { useBreakPoints } from "@omnia/fx/ux";
+export declare class BreakpointStore extends Store {
+    private breakpoint;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    getters: {
+        currentBreakpoint: () => ReturnType<typeof useBreakPoints>;
+    };
+    mutations: {
+        updateBreakpoint: import("@omnia/fx/stores").StoreMutation<(breakpoint: ReturnType<typeof useBreakPoints>) => void, (breakpoint: import("@omnia/fx-models").Breakpoint) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+}

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

@@ -0,0 +1,31 @@
+import { GuidValue } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { PublishingChannelCategory } from "../models";
+export declare class ChannelCategoriesStore extends Store {
+    private editingItem;
+    private editState;
+    private items;
+    private channelCategoriesService;
+    private multilingualStore;
+    getters: {
+        items: () => PublishingChannelCategory[];
+        editingItem: () => PublishingChannelCategory;
+        groupByCategories: () => {
+            [key: string]: PublishingChannelCategory;
+        };
+        categoriesMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<PublishingChannelCategory[]>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    };
+    actions: {
+        ensureCategories: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: PublishingChannelCategory[]) => void, (failureReason: any) => void, () => Promise<PublishingChannelCategory[]>>;
+        deleteCategory: import("@omnia/fx/stores").StoreAction<unknown, (category: PublishingChannelCategory) => void, (result: string, category: PublishingChannelCategory) => void, (failureReason: any, category: PublishingChannelCategory) => void, (category: PublishingChannelCategory) => Promise<string>>;
+        addOrUpdate: import("@omnia/fx/stores").StoreAction<unknown, (category: PublishingChannelCategory) => void, (result: PublishingChannelCategory, category: PublishingChannelCategory) => void, (failureReason: any, category: PublishingChannelCategory) => void, (category: PublishingChannelCategory) => Promise<PublishingChannelCategory>>;
+        updateCategoriesOrders: import("@omnia/fx/stores").StoreAction<unknown, (ids: GuidValue[]) => void, (result: null, ids: GuidValue[]) => void, (failureReason: any, ids: GuidValue[]) => void, (ids: Array<GuidValue>) => Promise<null>>;
+    };
+    mutations: {
+        setEditState: import("@omnia/fx/stores").StoreMutation<(item: PublishingChannelCategory) => void, (item: PublishingChannelCategory) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setCreateState: import("@omnia/fx/stores").StoreMutation<() => void, () => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateCategories: import("@omnia/fx/stores").StoreMutation<() => void, () => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,93 @@
+import { GuidValue, Identity, type IOmniaContext, MediaPickerImage, MultilingualString, ResolvedUserIdentity } from "@omnia/fx-models";
+import { TargetingFilterProperty } from "@omnia/fx-sp/models";
+import { MediaPickerService } from "@omnia/fx/services";
+import { MultilingualStore, Store } from "@omnia/fx/stores";
+import { PublishingChannel, PageId, PublishingChannelPage } from "../models";
+import { PublishingChannelId, ChannelPage } from "../models";
+import { TopicsActivityStore } from "./TopicsActivityStore";
+export interface ChannelIdtoChannelMap {
+    [channelId: number]: PublishingChannel;
+}
+export interface ChannelPageGroupMapping {
+    [channelId: number]: Array<number>;
+}
+export declare class ChannelManagementStore extends Store {
+    private channelService;
+    protected omniaContext: IOmniaContext;
+    mediaPickerService: MediaPickerService;
+    multilingualStore: MultilingualStore;
+    private userTargetingStore;
+    topicsActivityStore: TopicsActivityStore;
+    publishingChannels: import("@omnia/fx/stores").StoreState<ChannelIdtoChannelMap>;
+    waitingforApproveList: import("@omnia/fx/stores").StoreState<ChannelPageGroupMapping>;
+    resolvedUser: import("@omnia/fx/stores").StoreState<ResolvedUserIdentity>;
+    pendingChangeChannelPages: import("@omnia/fx/stores").StoreState<{
+        [pageId: string]: boolean;
+    }>;
+    private recentlyUsedChannels;
+    private publishedChannelsPage;
+    private userPublishingChannelSubscripton;
+    private ensuredUserPublishingChannelSubscriptonPromise;
+    private publishedChannelsOfPageLoadPromise;
+    channelPages: import("@omnia/fx/stores").StoreState<{
+        [key: string]: ChannelPage[];
+    }>;
+    private channelPagesLoadPromise;
+    private isPublishingPageToChannels;
+    private ensuredLoadDataPromise;
+    private ensuredGetPublishingChannelsPromise;
+    private userAuthorizedChannelResources;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        getRecentlyUsedChannels: () => PublishingChannel[];
+        getPublishedChannelsPage: () => {
+            [key: string]: PublishingChannelPage[];
+        };
+        getPublishingChannels: () => PublishingChannel[];
+        getPublisingChannelbyId: (channelId: PublishingChannelId) => PublishingChannel;
+        hasPublisherPermission: (channel: PublishingChannel, userIdentity: string) => boolean;
+        hasAssignChannelAdminPermission: (channel: PublishingChannel, userIdentity: string) => boolean;
+        hasAssignPublisherPermission: (channel: PublishingChannel, userIdentity: string) => boolean;
+        getChannelPages: (pageId: PageId) => ChannelPage[];
+        isPublishingPageToChannels: (pageId: PageId) => boolean;
+        getWaitingforApprovalPages: (channelId: PublishingChannelId) => number[];
+        getAllPublishingChannels: () => PublishingChannel[];
+        getUserPublishingChannelSubscripton: () => Array<PublishingChannel>;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        addOrUpdatePublishingChannel: import("@omnia/fx/stores").StoreMutation<(createdChannels: Array<PublishingChannel>) => void, (createdChannels: PublishingChannel[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        deletePublishingChannel: import("@omnia/fx/stores").StoreMutation<(deleteChannel: PublishingChannel) => void, (deleteChannel: PublishingChannel) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateChannelPages: import("@omnia/fx/stores").StoreMutation<(pageId: PageId, result: Array<ChannelPage>) => void, (pageId: PageId, result: ChannelPage[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateIsPublishingPageToChannels: import("@omnia/fx/stores").StoreMutation<(pageId: PageId, isPublishing: boolean) => void, (pageId: PageId, isPublishing: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateWaitingforApprovalPages: import("@omnia/fx/stores").StoreMutation<(channelPages: Array<ChannelPage>) => void, (channelPages: ChannelPage[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setPendingChanges: import("@omnia/fx/stores").StoreMutation<(pageId: number, pendingChanges: boolean) => void, (pageId: number, pendingChanges: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        ensureUserPermission: import("@omnia/fx/stores").StoreAction<unknown, (userIdentity: string) => void, (result: boolean, userIdentity: string) => void, (failureReason: any, userIdentity: string) => void, (userIdentity: string) => Promise<boolean>>;
+        ensurePublishingChannels: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: PublishingChannel[]) => void, (failureReason: any) => void, () => Promise<Array<PublishingChannel>>>;
+        ensureLoadData: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
+        ensureChannelPages: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: boolean, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<boolean>>;
+        ensurePublishedChannelsByPageId: import("@omnia/fx/stores").StoreAction<unknown, (pageId: PageId) => void, (result: boolean, pageId: PageId) => void, (failureReason: any, pageId: PageId) => void, (pageId: PageId) => Promise<boolean>>;
+        ensurePublishingChannel: import("@omnia/fx/stores").StoreAction<unknown, (channelId: number) => void, (result: PublishingChannel, channelId: number) => void, (failureReason: any, channelId: number) => void, (channelId: number) => Promise<PublishingChannel>>;
+        createPublishingChannel: import("@omnia/fx/stores").StoreAction<unknown, (title: MultilingualString, description: MultilingualString, publicUrl: string, owner: Identity[], image: MediaPickerImage, administrator: Identity[], publisher: Identity[], targetingFilter: TargetingFilterProperty, publishingCategoryId?: GuidValue) => void, (result: PublishingChannel, title: MultilingualString, description: MultilingualString, publicUrl: string, owner: Identity[], image: MediaPickerImage, administrator: Identity[], publisher: Identity[], targetingFilter: TargetingFilterProperty, publishingCategoryId?: GuidValue) => void, (failureReason: any, title: MultilingualString, description: MultilingualString, publicUrl: string, owner: Identity[], image: MediaPickerImage, administrator: Identity[], publisher: Identity[], targetingFilter: TargetingFilterProperty, publishingCategoryId?: GuidValue) => void, (title: MultilingualString, description: MultilingualString, publicUrl: string, owner: Array<Identity>, image: MediaPickerImage, administrator: Array<Identity>, publisher: Array<Identity>, targetingFilter: TargetingFilterProperty, publishingCategoryId?: GuidValue) => Promise<PublishingChannel>>;
+        updatePublishingChannel: import("@omnia/fx/stores").StoreAction<unknown, (editRequest: PublishingChannel) => void, (result: PublishingChannel, editRequest: PublishingChannel) => void, (failureReason: any, editRequest: PublishingChannel) => void, (editRequest: PublishingChannel) => Promise<PublishingChannel>>;
+        deletePublishingChannel: import("@omnia/fx/stores").StoreAction<unknown, (channelId: PublishingChannelId) => void, (result: PublishingChannel, channelId: PublishingChannelId) => void, (failureReason: any, channelId: PublishingChannelId) => void, (channelId: PublishingChannelId) => Promise<PublishingChannel>>;
+        getPageApprovalList: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: ChannelPage[]) => void, (failureReason: any) => void, () => Promise<Array<ChannelPage>>>;
+        approvePublishPageToChannelRequest: import("@omnia/fx/stores").StoreAction<unknown, (channel: PublishingChannel, pageId: PageId, pageTitle: string, pageUrl: string) => void, (result: ChannelPage, channel: PublishingChannel, pageId: PageId, pageTitle: string, pageUrl: string) => void, (failureReason: any, channel: PublishingChannel, pageId: PageId, pageTitle: string, pageUrl: string) => void, (channel: PublishingChannel, pageId: PageId, pageTitle: string, pageUrl: string) => Promise<ChannelPage>>;
+        rejectPublishPageToChannelRequest: import("@omnia/fx/stores").StoreAction<unknown, (channel: PublishingChannel, pageId: PageId, comment: string, pageTitle: string, pageUrl: string) => void, (result: ChannelPage, channel: PublishingChannel, pageId: PageId, comment: string, pageTitle: string, pageUrl: string) => void, (failureReason: any, channel: PublishingChannel, pageId: PageId, comment: string, pageTitle: string, pageUrl: string) => void, (channel: PublishingChannel, pageId: PageId, comment: string, pageTitle: string, pageUrl: string) => Promise<ChannelPage>>;
+        addPageToChannels: import("@omnia/fx/stores").StoreAction<unknown, (pageId: number, defaultPublishingChannelId: PublishingChannelId) => void, (result: ChannelPage[], pageId: number, defaultPublishingChannelId: PublishingChannelId) => void, (failureReason: any, pageId: number, defaultPublishingChannelId: PublishingChannelId) => void, (pageId: number, defaultPublishingChannelId: PublishingChannelId) => Promise<Array<ChannelPage>>>;
+        publishPageToChannels: import("@omnia/fx/stores").StoreAction<unknown, (pageId: number) => void, (result: ChannelPage[], pageId: number) => void, (failureReason: any, pageId: number) => void, (pageId: number) => Promise<Array<ChannelPage>>>;
+        publishAddedPageToChannel: import("@omnia/fx/stores").StoreAction<unknown, (pageId: number) => void, (result: ChannelPage[], pageId: number) => void, (failureReason: any, pageId: number) => void, (pageId: number) => Promise<Array<ChannelPage>>>;
+        ensureUserPublishingChannelSubscripton: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
+    };
+    private updateChannelPagesStatus;
+    private mappingPublishingChannels;
+    private addOrUpdateUserPermissions;
+}

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

@@ -0,0 +1,39 @@
+import { GuidValue } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { PageTitleConfig } from "../internal/models/PageTitleConfig";
+import { PageData, PageWithNavigationCreationRequest, VersionedPageData } from "../models";
+import { PagesStore } from "./PagesStore";
+export declare class CreatePageFormStore extends Store {
+    pagesStore: PagesStore;
+    pageTitleConfig: import("@omnia/fx/stores").StoreState<PageTitleConfig>;
+    properties: import("@omnia/fx/stores").StoreState<{
+        [propertyInternalName: string]: any;
+    }>;
+    private ensurePropertiesReady;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        isVisible: () => boolean;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        setPageTitle: import("@omnia/fx/stores").StoreMutation<(data: PageTitleConfig) => void, (data: PageTitleConfig) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        /**
+         *  Setup Form
+         * */
+        setupForm: import("@omnia/fx/stores").StoreMutation<(enterpriseProperties: {
+            [propertyInternalName: string]: any;
+        }, pageTitleConfig: PageTitleConfig) => void, (enterpriseProperties: {
+            [propertyInternalName: string]: any;
+        }, pageTitleConfig: PageTitleConfig) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        registerAfterPageCreatedHook: import("@omnia/fx/stores").StoreMutation<(ensurePropertiesReady: (versionPageData: VersionedPageData<PageData>) => Promise<any>) => void, (ensurePropertiesReady: (versionPageData: VersionedPageData<PageData>) => Promise<any>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        createPage: import("@omnia/fx/stores").StoreAction<unknown, (creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, (result: VersionedPageData<PageData>, creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, (failureReason: any, creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => void, (creationRequest: PageWithNavigationCreationRequest, targetPublishingAppId?: GuidValue, targetVariationId?: string) => Promise<VersionedPageData<PageData>>>;
+    };
+}

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,56 @@
+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;
+        hasChildrenLoadTriggered: (node: NavigationNode<NavigationData>) => boolean;
+        onActiveNodesMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<NavigationNode<NavigationData>[]>) => void) => IMessageBusSubscriptionHandler;
+        status: () => CurrentNavigationStatus;
+        readyPromise: () => Future<void>;
+    };
+    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>>;
+    };
+}