@omnia/wcm 8.0.0-vnext → 8.0.1-vnext

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

@@ -0,0 +1,211 @@
+import { ServiceContainerContext } from "@omnia/fx";
+import { EnterprisePropertyDefinition, FilterEngineSearchBoxSettings, GuidValue, IBlockInstance, RollupFilter, TargetingPropertyFlatResult } from "@omnia/fx-models";
+import { TermStore } from "@omnia/fx-sp";
+import { EnterpriseGlossaryStore, MultilingualStore } from "@omnia/fx/stores";
+import { FilterEngineHandler, IBlockInstanceExtends } from "@omnia/fx/ux";
+import { BatchQueryPages, BatchQueryPagesResult, NormalPageRollupPagingQuery, PageCollectionSelection, PageDialogData, PageDialogPropertiesMapping, PageItemNode, PageQuery, PageRollupBlockProperty, PageRollupBlockSettings, PageRollupEnums, PageRollupPropertyFilter, PageRollupUiFilter, QueryFilter, QueryOrder, ReactivePageBlockProperty, VariationId, VariationQuery } from "../../fx/models";
+interface BlockPageRollupInstanceExtends extends IBlockInstanceExtends<PageRollupBlockSettings> {
+    uiQueryFilters?: QueryFilter[];
+    orderBy?: Array<QueryOrder>;
+    cacheQuery?: BatchQueryPages;
+    blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>;
+    pagingQuery?: NormalPageRollupPagingQuery;
+    originalSettings?: PageRollupBlockSettings;
+    isShowMetric?: boolean;
+}
+interface BatchQueryPagesExtends extends BatchQueryPages {
+    concatResult?: boolean;
+    queryParrallelIndex?: number;
+}
+declare class InternalPageRollupStoreHelper {
+    private pageQueryService;
+    private pageRollupStore;
+    private propertyStore;
+    private targetingPropertyStore;
+    private currentPageStore;
+    private currentNavigationStore;
+    private targetingStore;
+    private variationStore;
+    private pagesStore;
+    private appInfoStore;
+    private omniaContext;
+    private breakpointStore;
+    private termNavigationStore;
+    private channelManagementStore;
+    enterpriseGlossaryStore: EnterpriseGlossaryStore;
+    termStore: TermStore;
+    private multilingualStore;
+    private resolvablePageRollupInNP;
+    private pageRollupInstancesInNP;
+    private pageRollupInstances;
+    private notificationPanelInstances;
+    private taxonomyPropertySettings;
+    private tagsProperties;
+    private tagsPropertySettings;
+    private contentProperties;
+    private initialDataResolvable;
+    private _pageBlockPropertyStore;
+    private currentIdentity;
+    private cancelBatchQueryToken;
+    private executingBatchQuery;
+    private hasNewBatchQueryNeedToExecute;
+    private pagerollupOutsideWCMLayout;
+    private executingQueriesStatus;
+    private excludeCountry;
+    private currentUserLanguage;
+    private keywordTermSet;
+    private loadedPageRollups;
+    init(): void;
+    getPagingData(pagingQuery: NormalPageRollupPagingQuery, blockInstance: BlockPageRollupInstanceExtends, newSettings: PageRollupBlockSettings, uiQueryFilters: QueryFilter[], orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): Promise<number>;
+    updatePagingQuery(pagingQuery: NormalPageRollupPagingQuery, blockInstance: BlockPageRollupInstanceExtends): Promise<void>;
+    setPagingNumber(pageNumber: number, blockInstance: BlockPageRollupInstanceExtends): Promise<void>;
+    updateQuery(blockInstance: BlockPageRollupInstanceExtends, newSettings: PageRollupBlockSettings, uiQueryFilters: QueryFilter[], orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>, forceExecuteQuery?: boolean, clientCaching?: boolean, showMetric?: boolean): void;
+    getRollupId(blockInstance: IBlockInstance<PageRollupBlockSettings>): string;
+    setLoadedPageRollups(pageRollupQueryId: string, isDestroyed: boolean): void;
+    private setExecutingQueriesParrallel;
+    private setExecutedQueriesParrallel;
+    private ensureLatestExecutedQuery;
+    hasQueryResourceConfiguration(settings: PageRollupBlockSettings): boolean | PageRollupEnums.RollupScopes;
+    getPickedPages(settings: PageRollupBlockSettings, instance: IBlockInstance<PageRollupBlockSettings>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): PageItemNode[];
+    ensureUserTargetingData(settings: PageRollupBlockSettings): Promise<TargetingPropertyFlatResult[]>;
+    ensureLoadedCurrentNavigation(blockInstances: IBlockInstanceExtends<PageRollupBlockSettings>[]): Promise<void>;
+    getTargetingData(settings: PageRollupBlockSettings): TargetingPropertyFlatResult[];
+    getResourceId(resourceId: string): string;
+    getStartNode(settings: PageRollupBlockSettings): PageItemNode;
+    private generateNavigationPathFilters;
+    private getStartNodePromise;
+    private ensureValidCalendarDateProp;
+    private generateCalendarFilter;
+    generateFilters(settings: PageRollupBlockSettings, filters?: Array<PageRollupPropertyFilter>): Array<QueryFilter>;
+    private isProcessProperty;
+    private getProcessFilters;
+    getVariationQuery(settings: PageRollupBlockSettings, serviceContainerContext: ServiceContainerContext): Promise<{
+        ids: VariationId[];
+        queries: VariationQuery[];
+    }>;
+    populateTargetingVariationIds(variationQueriesDict: {
+        [key: number]: VariationQuery;
+    }, settings: PageRollupBlockSettings, pageCollectionSelections: Array<PageCollectionSelection>): any[];
+    buildQuery(serviceContainerContext: ServiceContainerContext, settings: PageRollupBlockSettings, instance: IBlockInstance<PageRollupBlockSettings>, uiQueryFilters: QueryFilter[]): Promise<PageQuery>;
+    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(blockInstance: BlockPageRollupInstanceExtends, settings: PageRollupBlockSettings, uiQueryFilters: QueryFilter[], orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): Promise<BatchQueryPages>;
+    private generateChannelsFilter;
+    private generateChannelsFilterForChannelsScope;
+    private getPropertyNameByScope;
+    private scopeHasVariationFilter;
+    private validateSetting;
+    private buildUserTargetingQuery;
+    private getInstancesToBatchQuery;
+    private ensureInitialData;
+    private get pageBlockPropertyStore();
+    private updateVariationQueries;
+    private hasVariationQueryFilter;
+    private hasVariationValueQueryFilter;
+    private runBatchQueryForInstances;
+    private executeIndexedDB;
+    private runIsolatedBatchQueryForInstances;
+    private buildUIFiltersForBlockInstance;
+    private isNotBreakpointSettings;
+    private buildQueries;
+    private ensurePublishingAppsAndPageCollectionsReady;
+    private updateRollupRelevantApps;
+    private ensureUpdatePublishingChannelsFilterItems;
+    private hookupPageRollupsInWcmLayout;
+    private ensureMigrateData;
+    private mergeDefaultSettings;
+    private mergePageRollupInstances;
+    private extractPageRollupInstancesInNP;
+    private pushBatchQueryTimewatch;
+    private ensureRunLatestBatchQuery;
+    executeBatchQuery(queries: BatchQueryPagesExtends[], queryWithPageTypes: Array<string>, allowCancelToken?: boolean, clientCaching?: boolean): Promise<BatchQueryPagesResult>;
+    private mapToBatchQueryPages;
+    private hasPageTypeSettingInView;
+    private hasTagOrTaxonomyInView;
+    needToLoadPageTypeInView(settings: PageRollupBlockSettings, internalNames: Array<string>): boolean;
+    private hasPageTypeSettingInQuery;
+    private hasAppInSettings;
+    private ensureLoadPageTypesOfInstance;
+    private ensureLoadPageTypes;
+    private ensureLanguageSettings;
+}
+export declare class PageRollupStoreHelper {
+    private internal;
+    constructor();
+    registerBatchQuery(blockInstance: IBlockInstanceExtends<PageRollupBlockSettings>, blockProperty: ReactivePageBlockProperty<PageRollupBlockProperty>, uiFilterHandler: FilterEngineHandler, orderBy: Array<QueryOrder>): BatchQueryRegistration;
+    ensureUserTargetingData(settings: PageRollupBlockSettings): Promise<TargetingPropertyFlatResult[]>;
+    getRollupId(blockInstance: IBlockInstance<PageRollupBlockSettings>): string;
+    hasQueryResourceConfiguration(settings: PageRollupBlockSettings): boolean | PageRollupEnums.RollupScopes;
+    getPickedPages(settings: PageRollupBlockSettings, instance: IBlockInstance<PageRollupBlockSettings>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): PageItemNode[];
+    getTargetingData(settings: PageRollupBlockSettings): TargetingPropertyFlatResult[];
+    getResourceId(resourceId: string): string;
+    getStartNode(settings: PageRollupBlockSettings): PageItemNode;
+    generateFilters(settings: PageRollupBlockSettings, filters?: Array<PageRollupPropertyFilter>): Array<QueryFilter>;
+    getVariationQuery(settings: PageRollupBlockSettings, serviceContainerContext: ServiceContainerContext): Promise<{
+        ids: VariationId[];
+        queries: VariationQuery[];
+    }>;
+    getPagesDetails(pageIds: number[], selectProps: PageDialogPropertiesMapping, contentLimit?: number, reloadData?: boolean): Promise<PageDialogData>;
+    getPagesDetailsMetric(blockInstance: IBlockInstance<PageRollupBlockSettings>, settings: PageRollupBlockSettings, uiQueryFilters: QueryFilter[], orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>): Promise<void>;
+    setDestroyedPageRollups(pageRollupQueryId: string): void;
+    getBatchQueriesData(batchQueries: Array<BatchQueryPages>, queryWithPageTypes: Array<string>): Promise<BatchQueryPagesResult>;
+    needToLoadPageTypeInView(settings: PageRollupBlockSettings, internalNames: Array<string>): boolean;
+}
+export declare class FilterManager {
+    private static targetingPropertyStore;
+    static buildSearchQuery(filters: Array<RollupFilter>, searchText: string, enterprisePropertyDefinitions: EnterprisePropertyDefinition[], searchFilter: FilterEngineSearchBoxSettings, enableWildcardSearch: boolean, isChannelScope: boolean): QueryFilter[];
+    private static generatSearchFilter;
+    static isOPMProcessProperty(enterprisePropertyDefinition: EnterprisePropertyDefinition): boolean;
+    private static uiFilterMapper;
+    static generateUIFilters(settings: PageRollupBlockSettings, currentIdentity: string, promotedTagsSettings?: {
+        appInstanceId: GuidValue;
+        promotedTagProperties?: string[];
+    }): PageRollupUiFilter[];
+    private static mapPropValueFromRouter;
+    static generateUIQueryFilters(uiFilters: Array<RollupFilter>, enterprisePropertyDefinitions: EnterprisePropertyDefinition[], enableWildcardSearch: boolean, isChannelScope: boolean): QueryFilter[];
+    private static generateUIQueryFilter;
+    private static mapPageRollupUIFilter;
+    private static mapTextPropFilterValue;
+}
+/**
+ * Factory for Page Rollup settings
+ * */
+export declare const PageRollupConfigurationFactory: {
+    defaultSettings(): PageRollupBlockSettings;
+    defaultProperty(): PageRollupBlockProperty;
+    applyBreakPointSettings(settings: PageRollupBlockSettings, breakPoint: string, multilingualStore: MultilingualStore, originalSettings?: PageRollupBlockSettings): void;
+    saveBreakPointSettingsToBlockData(breakpointSettings: PageRollupBlockSettings, originalSettings: PageRollupBlockSettings, breakPoint: string): void;
+    isQueryBuilderScope(settings: PageRollupBlockSettings, ...expectedScopes: PageRollupEnums.RollupScopes[]): boolean;
+};
+export declare const EnsureMigrateBlockData: (settings: PageRollupBlockSettings) => void;
+export declare class BatchQueryRegistration {
+    private storeHelper;
+    private blockInstance;
+    private settings;
+    private blockProperty;
+    private uiFilterHandler;
+    private _orderBy;
+    private pagingObservableState;
+    constructor(storeHelper: InternalPageRollupStoreHelper, blockInstance: IBlockInstance<PageRollupBlockSettings>, settings: PageRollupBlockSettings, blockProperty: ReactivePageBlockProperty<PageRollupBlockProperty>, uiFilterHandler: FilterEngineHandler, _orderBy: Array<QueryOrder>);
+    updateQuery(settings: PageRollupBlockSettings, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>, orderBy?: Array<QueryOrder>, forceExecuteQuery?: boolean, clientCaching?: boolean): void;
+    updatePagingQuery(payload: NormalPageRollupPagingQuery): Promise<void>;
+    resetPaging(): Promise<void>;
+    execute(): void;
+    getPagingData(pageNumber: number): Promise<number>;
+    getNextPagingData(): Promise<number>;
+    private loadCurrentPageData;
+    generateBatchQuery(): Promise<BatchQueryPages>;
+    get orderBy(): QueryOrder[];
+    get pagingNumber(): number;
+    get pagingStateKey(): string;
+    get pagingNoNext(): boolean;
+    needToLoadPageTypeInView(internalNames: Array<string>): boolean;
+    /**
+     * Transform ui-filter-engine to query filter that used inside Page Rollup
+     *
+     *
+     * */
+    private generateQueryFilter;
+    private generateQueryablePropertyName;
+}
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { NotificationMessage } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { ApprovalRequest, ApprovalRuleData } from "../../models";
+import { ApprovalData, PublishingRule, PublishingRuleData, VersionId } from "../models";
+import { RejectPageInfo } from "../models/publishingrule/RejectPageInfo";
+export declare class PublishingRuleStore extends Store {
+    private publishingRuleService;
+    private omniaCtx;
+    private currentNavigationStore;
+    private pagesStore;
+    private currentPageStore;
+    private variationStore;
+    private fxLoc;
+    private resolvedUser;
+    private rules;
+    private rulePromises;
+    private isHaveApprovalRequest;
+    private isHaveScheduleApprovalRequest;
+    private isHaveSchedule;
+    private isHaveSupportedLanguage;
+    private isMachineTranslated;
+    onActivated(): void;
+    onDisposing(): void;
+    getters: {
+        getPublishingRules: (versionId: VersionId) => Array<PublishingRule>;
+        getScheduleMessege: (versionId: VersionId) => NotificationMessage;
+        isPageVersionHaveSchedule: (versionId: VersionId) => boolean;
+        isPageVersionHaveApprovalRequest: (versionId: VersionId) => boolean;
+        isPageVersionHaveScheduleApprovalRequest: (versionId: VersionId) => boolean;
+        isPageAutomaticMachineTranslate: (versionId: VersionId) => boolean;
+        onRulesMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<{
+            [versionId: number]: PublishingRule<PublishingRuleData>[];
+        }>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        isPublishingRuleExisted: (versionId: VersionId) => boolean;
+        canCancelApproval: (versionId: VersionId, approvalData: ApprovalData) => boolean;
+        canApproveOrReject: (versionId: VersionId, approvalData: ApprovalData) => boolean;
+    };
+    mutations: {
+        updateApprovalData: import("@omnia/fx/stores").StoreMutation<(ruleData: PublishingRule<ApprovalRuleData>) => void, (ruleData: PublishingRule<ApprovalRuleData>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateRules: import("@omnia/fx/stores").StoreMutation<(versionRules: Array<PublishingRule>, versionId: number) => void, (versionRules: PublishingRule<PublishingRuleData>[], versionId: number) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensurePageVersionRules: import("@omnia/fx/stores").StoreAction<unknown, (versionId: VersionId) => void, (result: void, versionId: VersionId) => void, (failureReason: any, versionId: VersionId) => void, (versionId: VersionId) => Promise<void>>;
+        sendApprovalRequest: import("@omnia/fx/stores").StoreAction<unknown, (request: ApprovalRequest) => void, (result: PublishingRule<ApprovalRuleData>, request: ApprovalRequest) => void, (failureReason: any, request: ApprovalRequest) => void, (request: ApprovalRequest) => Promise<PublishingRule<ApprovalRuleData>>>;
+        cancelApproval: import("@omnia/fx/stores").StoreAction<unknown, (ruleData: PublishingRule<ApprovalRuleData>) => void, (result: PublishingRule<PublishingRuleData>[], ruleData: PublishingRule<ApprovalRuleData>) => void, (failureReason: any, ruleData: PublishingRule<ApprovalRuleData>) => void, (ruleData: PublishingRule<ApprovalRuleData>) => Promise<Array<PublishingRule>>>;
+        approve: import("@omnia/fx/stores").StoreAction<unknown, (ruleData: PublishingRule<ApprovalRuleData>) => void, (result: PublishingRule<ApprovalRuleData>, ruleData: PublishingRule<ApprovalRuleData>) => void, (failureReason: any, ruleData: PublishingRule<ApprovalRuleData>) => void, (ruleData: PublishingRule<ApprovalRuleData>) => Promise<PublishingRule<ApprovalRuleData>>>;
+        reject: import("@omnia/fx/stores").StoreAction<unknown, (rejectPageInfo: RejectPageInfo) => void, (result: PublishingRule<PublishingRuleData>[], rejectPageInfo: RejectPageInfo) => void, (failureReason: any, rejectPageInfo: RejectPageInfo) => void, (rejectPageInfo: RejectPageInfo) => Promise<Array<PublishingRule>>>;
+        addRule: import("@omnia/fx/stores").StoreAction<unknown, (ruleData: PublishingRuleData, versionId: VersionId) => void, (result: PublishingRule<PublishingRuleData>, ruleData: PublishingRuleData, versionId: VersionId) => void, (failureReason: any, ruleData: PublishingRuleData, versionId: VersionId) => void, (ruleData: PublishingRuleData, versionId: VersionId) => Promise<PublishingRule>>;
+        deleteRule: import("@omnia/fx/stores").StoreAction<unknown, (rule: PublishingRule<PublishingRuleData>) => void, (result: PublishingRule<PublishingRuleData>, rule: PublishingRule<PublishingRuleData>) => void, (failureReason: any, rule: PublishingRule<PublishingRuleData>) => void, (rule: PublishingRule) => Promise<PublishingRule>>;
+        updateRules: import("@omnia/fx/stores").StoreAction<unknown, (rule: PublishingRule<PublishingRuleData>) => void, (result: PublishingRule<PublishingRuleData>, rule: PublishingRule<PublishingRuleData>) => void, (failureReason: any, rule: PublishingRule<PublishingRuleData>) => void, (rule: PublishingRule) => Promise<PublishingRule>>;
+    };
+    private checkPageVersionRules;
+}

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { Store } from "@omnia/fx/stores";
+export interface StackedUrl {
+    order: number;
+    url: string;
+}
+export declare class SessionUrlHistoryStore extends Store {
+    private previousUrlStack;
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        previousUrl: () => StackedUrl;
+        fullHistory: () => StackedUrl[];
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        push: import("@omnia/fx/stores").StoreMutation<(newState: string) => void, (newState: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+}

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

@@ -0,0 +1,50 @@
+import { GuidValue } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { Variation, VariationCreationRequest, VariationId } from "@omnia/wcm/models";
+export declare class VariationStore extends Store {
+    private omniaContext;
+    private variationService;
+    private wcmContext;
+    private userTargetingStore;
+    private subscriptionHandler;
+    private variationId;
+    private publishingAppVariations;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        getAppVariations: (appId?: GuidValue) => Variation[];
+        getVariation: (variationId: VariationId) => Variation;
+        getCurrentVariation: () => Variation;
+        getCurrentVariationForPublishingApp: (pubAppId: GuidValue) => Variation;
+        getDefaultVariation: (appId?: GuidValue) => Variation;
+        onVariationMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<{
+            [appId: string]: Variation[];
+        }>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        isVariationsEnabled: () => boolean;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {};
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        load: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: Variation[]) => void, (failureReason: any) => void, () => Promise<Variation[]>>;
+        loadFromPublishingAppId: import("@omnia/fx/stores").StoreAction<unknown, (publishingAppIds: GuidValue[]) => void, (result: {
+            [pubAppId: string]: Variation[];
+        }, publishingAppIds: GuidValue[]) => void, (failureReason: any, publishingAppIds: GuidValue[]) => void, (publishingAppIds: GuidValue[]) => Promise<{
+            [pubAppId: string]: Variation[];
+        }>>;
+        add: import("@omnia/fx/stores").StoreAction<unknown, (createRequest: VariationCreationRequest) => void, (result: Variation, createRequest: VariationCreationRequest) => void, (failureReason: any, createRequest: VariationCreationRequest) => void, (createRequest: VariationCreationRequest) => Promise<Variation>>;
+        update: import("@omnia/fx/stores").StoreAction<unknown, (variation: Variation) => void, (result: Variation, variation: Variation) => void, (failureReason: any, variation: Variation) => void, (variation: Variation) => Promise<Variation>>;
+        delete: import("@omnia/fx/stores").StoreAction<unknown, (variation: Variation) => void, (result: void, variation: Variation) => void, (failureReason: any, variation: Variation) => void, (variation: Variation) => Promise<void>>;
+        switchVariation: import("@omnia/fx/stores").StoreAction<unknown, (variation: Variation) => void, (result: any, variation: Variation) => void, (failureReason: any, variation: Variation) => void, (variation: Variation) => Promise<any>>;
+    };
+    private compareTargeting;
+    private getPublishingAppKey;
+    private get publishingAppId();
+}

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

@@ -0,0 +1,22 @@
+export * from "./PagesStore";
+export * from "./CurrentPageStore";
+export * from "./PublishingAppInfoStore";
+export * from "./CurrentNavigationStore";
+export * from "./NavigationStore";
+export * from "./VariationStore";
+export * from "./PublishingRuleStore";
+export * from "./PageRollupStore";
+export * from "./TopicsActivityStore";
+export * from "./BreadcrumbStore";
+export * from "./PageBlockPropertyStore";
+export * from "./BreakpointStore";
+export * from "./CurrentEventStore";
+export * from "./TargetingStore";
+export * from "./LinkPickerStore";
+export * from "./CreatePageFormStore";
+export * from "./IndexedDB";
+export * from "./ChannelManagementStore";
+export * from "./PageStatisticsStore";
+export * from "./AppInfoStore";
+export * from "./ChannelCategoriesStore";
+export * from "./UrlHistoryStore";