@omnia/wcm 8.0.1-dev → 8.0.2-dev

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

@@ -0,0 +1,9 @@
+import { PageId, PagePermissionResponse, NavigationNode, NavigationData } from "../models";
+import { Identity } from "@omnia/fx-models";
+export declare class PagePermissionService {
+    private httpClient;
+    private readonly baseUrl;
+    breakInheritance: (pageId: PageId, node: NavigationNode<NavigationData>) => Promise<PagePermissionResponse>;
+    inheritPermission: (pageId: PageId, node: NavigationNode<NavigationData>) => Promise<PagePermissionResponse>;
+    getHigherAuthorPermissions: (pageId: PageId, userIdentities: Identity[]) => Promise<Array<Identity>>;
+}

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

@@ -0,0 +1,26 @@
+import { PageCollectionSelection, ResolveReusablePageResult, PendingApprovalPage, PageId, SimplePageQuery, PageContentsQueryResult, BatchQueryPages, BatchQueryPagesResult, ExportQueryPagesRequest, ExportQueryPagesResult } from "../models";
+import { WcmContext } from "../contexts";
+import { MultilingualStore } from "@omnia/fx/stores";
+export declare class PageQueryService {
+    private httpClient;
+    private omniaHttpClient;
+    private omniaContext;
+    wcmContext: WcmContext;
+    multilingualStore: MultilingualStore;
+    constructor();
+    private static getPageCollectionSelectionsPromises;
+    private getUrlResolve;
+    resolvePageCollection: (url: string) => Promise<PageCollectionSelection>;
+    isPageBeingReused: (pageId: PageId) => Promise<boolean>;
+    resolveReusablePageById: (pageId: number) => Promise<ResolveReusablePageResult>;
+    queryBatchPages: (queries: BatchQueryPages[], cancelRequest?: (cancelToken: any) => void) => Promise<BatchQueryPagesResult>;
+    getPagesContents: (queryDetails: SimplePageQuery) => Promise<PageContentsQueryResult[]>;
+    getDefaultPageImageSrc: () => string;
+    exportToExcel: (query: ExportQueryPagesRequest, exportingBlockId: string) => Promise<ExportQueryPagesResult>;
+    getExportedFile: (exportingFileName: string, exportingFileToken: string) => Promise<void>;
+    checkMigrationOmniaSearchStatus: () => Promise<boolean>;
+    private processPagesDetailData;
+    private getPageVisited;
+    private findPageInNode;
+    getPendingApprovalPages: () => Promise<Array<PendingApprovalPage>>;
+}

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

@@ -0,0 +1,95 @@
+import { Page, PageData, CheckedOutVersionPageData, VersionedPageData, PublishedVersionPageData, PageIdToPageMap, PageId, VariationPage, PageCollectionSelection, NavigationData, NavigationNode, MovePagesResult, VersionInformation, ArchivePageResult, RestorePageMessage, RestorePageResult, VariationId, PageWithNavigationCreationRequest, PageNavigationNode, PageNavigationData, ReadNews, PagePermissionResponse, ValidationArchivePageResult, PageTypeTitle, VersionId, ApprovalMetaData } from "../models";
+import { MergedPageVersionLayout } from "../models/layout/MergedPageVersionLayout";
+import { ApiResponse, GuidValue } from "@omnia/fx-models";
+import { VersionReference } from "../models";
+import { NavigationPosition } from "../models/navigation/NavigationPosition";
+import { CreatedPageWithNavigationInfo, CreatedPageInfo } from "../models";
+import { PagePermissionInfo } from "../models";
+import { EnterprisePropertyStore } from "@omnia/fx/stores";
+import { InvitationOfAuthor } from "../../models";
+export declare class PageService {
+    private httpClient;
+    enterprisePropertyStore: EnterprisePropertyStore;
+    private multilingualStore;
+    static appIdQuery: {};
+    static obsoleteSetWCMApp(appId: GuidValue): void;
+    private readonly baseUrl;
+    private readonly reusablePageBaseUrl;
+    createVariationPage: <T extends PageData>(pageData: T, originalPageId: PageId, variationId: VariationId) => Promise<CreatedPageInfo<T>>;
+    updatePagePermissions: (pageId: PageId, permissionInfo: PagePermissionInfo, 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>;
+    movePageTypeToTenant: (page: Page) => Promise<PageNavigationNode<PageNavigationData>>;
+    attachPageWithNavigation: <T extends PageData>(pageData: T, urlSegment: string, position: NavigationPosition) => Promise<CreatedPageWithNavigationInfo<T>>;
+    /**
+     * Archive the page with the given id, and also all navigation nodes related to the page
+     * */
+    archive: (pageId: PageId, comment: string) => Promise<ArchivePageResult>;
+    /**
+    * Validate an archive the page with the given id
+    * */
+    validateArchivePage: (pageId: PageId) => Promise<ValidationArchivePageResult>;
+    /**
+    * Switch parent page from pageId to another pageId
+    * */
+    switchParentPage: (fromPageId: PageId, toPageId: PageId) => Promise<void>;
+    /**
+     * Restore the page with page archive information
+     * */
+    restore: (message: RestorePageMessage) => Promise<RestorePageResult>;
+    getAllPages: (typesToGet?: number, targetPublishingAppId?: string, tenantScopeOnly?: boolean, excludeUnavailable?: boolean) => Promise<Array<Page>>;
+    getPageDataPageTypes: (publishingAppIds?: string[], all?: boolean, tenantScope?: boolean) => Promise<Array<PageTypeTitle>>;
+    getPageTypesTitle: (pageTypeIds: number[]) => Promise<Array<PageTypeTitle>>;
+    getPage: (pageId: PageId, targetPublishingAppId?: string) => Promise<Page>;
+    copyPage: <T extends PageData>(pageId: PageId, targetParentPageId?: PageId, targetPublishingAppId?: string) => Promise<CreatedPageWithNavigationInfo<T>>;
+    /**
+     * Create a copy of variation page by page id. This api is only supported for non-default variation page.
+       This api is only supposed to used for creating a draft when archiving non-default variation page.
+       The new created copy page will be an orphaned page (not associated to neither NavigationNode nor PageVariation).
+       The reason for doing it is that we need to create the copy before archiving the source page.
+       As a result, the copied page cannot attach to the variation at this stage. We  will call AttachVariationPageAsync after that for this purpose.
+       Please use it with care! Use copyPage if you need to copy page and create a new navigation node for the copy.
+     * @param pageId
+     * @param targetPublishingAppId
+     */
+    copyVariationPage: <T extends PageData>(pageId: PageId, targetPublishingAppId?: string) => Promise<CreatedPageInfo<T>>;
+    /**
+     * Attach an orphaned page as a variation page for the specified orginal page Id.
+     * The variationPageId must belong to an orphaned page for it to work.
+     * This api is only supposed to used for creating a draft when archiving non-default variation page.
+     * Please check the comment for CopyVariationPageAsync to understand the reason behind it.
+     * @param originalPageId
+     * @param variationPageId
+     * @param variationId
+     * @param targetPublishingAppId
+     */
+    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>>;
+    /**
+     * 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>>;
+    getCheckedOutVersion: (pageId: PageId) => Promise<CheckedOutVersionPageData<PageData>>;
+    publish: <T extends PageData>(versionToPublish: VersionedPageData<T>, targetPublishingAppId?: string) => Promise<PublishedVersionPageData<T>>;
+    unPublish: <T extends PageData>(versionToUnPublish: PublishedVersionPageData<T>) => Promise<VersionedPageData<T>>;
+    getPublishedVersion: (pageId: PageId, targetPublishingAppId?: string) => Promise<PublishedVersionPageData<PageData>>;
+    /**
+     * Merges the source layout values into target layout
+     */
+    mergeVersionWithParentLayoutLayouts: (versionRef: VersionReference, layoutLatestPublishedVersionId?: number) => Promise<MergedPageVersionLayout>;
+    checkSharepointPageExist: (spPageId: number) => Promise<boolean>;
+    getVersionInformation: (pageId: PageId) => Promise<Array<VersionInformation>>;
+    revert: <T extends PageData>(versiontoRevert: VersionedPageData<T>) => Promise<VersionedPageData<T>>;
+    getPageCollectionSelection: (fromPublishingAppId: string, fromPageCollectionIds?: Array<string>) => Promise<ApiResponse<PageCollectionSelection[]>>;
+    private tempFixDateTimeFormatInEnterpriseProperty;
+    visitedpage: (pageId: PageId) => Promise<ReadNews>;
+    inviteCoAuthors: (invitationAuthors: InvitationOfAuthor) => Promise<PagePermissionResponse>;
+    getSitePagesFolderFullUrl: (pageNavigationNode: PageNavigationNode<PageNavigationData>) => Promise<string>;
+    getPageVersionMetaData: (versionId: VersionId) => Promise<ApprovalMetaData>;
+}

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

@@ -0,0 +1,20 @@
+import { PageRollupEnums } from "@omnia/wcm/models";
+import { PageReportByUserPropertiesOption, PageReportOption, PageViewedRegister, ScheduledReportItem, UniqueUsersByUserProperty } from "../../models";
+import { UsageReportItem, CheckedOutReportItem, ReviewReportItem, DailyStatisticsPerPage, PageStatisticExport } from "../../models";
+export declare class PageStatisticsService {
+    private httpClient;
+    private omniaContext;
+    constructor();
+    createPageStatistics(pageViewedRegister: PageViewedRegister): Promise<any>;
+    getUsageReport(reportOptions: PageReportOption): Promise<Array<UsageReportItem>>;
+    getUsageReportByUserProperties(reportOptions: PageReportByUserPropertiesOption): Promise<UsageReportItem>;
+    getCheckedOutReport(reportOptions: PageReportOption): Promise<Array<CheckedOutReportItem>>;
+    getReviewReport(reportOptions: PageReportOption): Promise<Array<ReviewReportItem>>;
+    getScheduledReport(reportOptions: PageReportOption): Promise<Array<ScheduledReportItem>>;
+    exportUsageReport(reportOptions: PageReportOption): Promise<PageStatisticExport>;
+    exportCheckoutReport(reportOptions: PageReportOption): Promise<PageStatisticExport>;
+    exportReviewReport(reportOptions: PageReportOption): Promise<PageStatisticExport>;
+    exportScheduledReport(reportOptions: PageReportOption): Promise<PageStatisticExport>;
+    getDailyStatisticsPerPage(pageId: number, includeSubPages: boolean): Promise<Array<DailyStatisticsPerPage>>;
+    getPageUniqueUsersByUserProperty(pageId: number, propertyName: string, datePeriods: PageRollupEnums.DatePeriods): Promise<Array<UniqueUsersByUserProperty>>;
+}

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

@@ -0,0 +1,15 @@
+import { OmniaContext } from "@omnia/fx";
+import { Participant } from "../models";
+import { PageId } from "@omnia/wcm/models";
+export declare const BASE_URL = "api/participants";
+export declare class ParticipantService {
+    omniaContext: OmniaContext;
+    private httpClient;
+    constructor();
+    getParticipantByLoginNameOrEmail: (loginNameOrEmail: string, pageId: number) => Promise<Participant>;
+    getParticipants: (pageId: PageId) => Promise<Array<Participant>>;
+    addOrUpdateParticipant: (participant: Participant) => Promise<Participant>;
+    deleteParticipant: (participant: Participant) => Promise<Participant>;
+    moveParticipantToStandbyList: (participant: Participant) => Promise<Participant>;
+    moveParticipantToOfficialList: (participant: Participant) => Promise<Participant>;
+}

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

@@ -0,0 +1,12 @@
+import { GuidValue } from "@omnia/fx-models";
+import { PublishingChannelCategory } from "../models";
+export declare class PublishingChannelCategoriesService {
+    private httpClient;
+    private readonly baseUrl;
+    getAllCategories: () => Promise<Array<PublishingChannelCategory>>;
+    getCategoryById: (id: GuidValue) => Promise<PublishingChannelCategory>;
+    createCategory: (category: PublishingChannelCategory) => Promise<PublishingChannelCategory>;
+    updateCategory: (category: PublishingChannelCategory) => Promise<PublishingChannelCategory>;
+    deleteCategory: (id: GuidValue) => Promise<null>;
+    orderCategories: (ids: Array<GuidValue>) => Promise<null>;
+}

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

@@ -0,0 +1,19 @@
+import { PageId, PublishingRule, PublishingRuleData, PageData, ApprovalRequestInfo, SendBackPageInfo, ApprovePageInfo } from "../models";
+import { RejectPageInfo } from "../models/publishingrule/RejectPageInfo";
+import { ApprovalRuleData } from "../../models";
+export declare class PublishingRuleService {
+    private httpClient;
+    private readonly baseUrl;
+    addRule: (rule: PublishingRuleData, pageId: PageId) => Promise<PublishingRule>;
+    getPageRules: (pageId: PageId) => Promise<{
+        [pageId: number]: PublishingRule<PublishingRuleData>[];
+    }>;
+    updateRule: (rule: PublishingRule) => Promise<PublishingRule>;
+    cancelApproval: (rule: PublishingRule<ApprovalRuleData>) => Promise<Array<PublishingRule>>;
+    approveApproval: (approvePageInfo: ApprovePageInfo) => Promise<PublishingRule<ApprovalRuleData>>;
+    rejectApproval: (rejectPageInfo: RejectPageInfo) => Promise<Array<PublishingRule>>;
+    sendBackApproval: (sendBackPageInfo: SendBackPageInfo) => Promise<PublishingRule>;
+    deleteRule: (id: number) => Promise<PublishingRule>;
+    getPageUnassignedRules: (pageId: PageId) => Promise<Array<PublishingRule>>;
+    sendApprovalRequest: <T extends PageData>(approvalRequestInfo: ApprovalRequestInfo<T>) => Promise<PublishingRule<ApprovalRuleData>[]>;
+}

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

@@ -0,0 +1,13 @@
+import { PageId } from "@omnia/wcm/models";
+import { ReusablePages } from "../models";
+export declare class ReusablePageService {
+    private httpClient;
+    private readonly baseUrl;
+    getTargetPagesInfo: (sourcePageId: PageId, ensureImplicitSync?: boolean) => Promise<Array<ReusablePages>>;
+    /**
+     * @deprecated Removed in 7.0
+     */
+    publishAll: (sourcePageId: PageId) => Promise<Array<ReusablePages>>;
+    retryToPublish: (targetPageId: PageId, targetPubappId: string) => Promise<ReusablePages>;
+    getPageInfo: (targetPageId: PageId) => Promise<ReusablePages>;
+}

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

@@ -0,0 +1,6 @@
+import { CategorySearchResult, SearchRequest } from "@omnia/workplace/models";
+export declare class SearchService {
+    private httpClient;
+    private readonly baseUrl;
+    getCommentSearchResult: (searchRequest: SearchRequest) => Promise<Array<CategorySearchResult>>;
+}

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

@@ -0,0 +1,49 @@
+import { TopicFilterPagedResult, TopicFilterPagingToken } from "../models";
+import { TopicSubscription } from "../models";
+import { Topic } from "../models";
+import { TopicWithFilter } from "../models";
+import { TopicInformation, ActivityFilterPagingToken, ActivityFilterPagedResult } from "../models";
+import { ActivityFilter } from "../models/social/Activities/ActivityFilter";
+export declare class TopicActivityService {
+    private httpClient;
+    private readonly baseUrl;
+    /***
+     * Ensures that the current user is subscribing to the topics
+     *
+     * **/
+    subscribe: <T extends Topic>(topicsToSubscribe: T[]) => Promise<Array<TopicSubscription>>;
+    /***
+     * Unsubscribe to topic subscriptions
+     *
+     * Returns the remaning subscriptions after unsubscribe
+     * **/
+    unSubscribe: (topicsToUnsubscribe: Array<TopicSubscription>) => Promise<Array<TopicSubscription>>;
+    /***
+     * Get subscriptions
+     * **/
+    getSubscriptions: () => Promise<Array<TopicSubscription>>;
+    /***
+     * Get topic activities for specified topics
+     * **/
+    getTopicActivities: (topicsWithFilter: Array<TopicWithFilter>) => Promise<TopicFilterPagedResult>;
+    /***
+     * Get topic activities for specified topics
+     * **/
+    getActivities: (filter: ActivityFilter) => Promise<ActivityFilterPagedResult>;
+    /***
+     * 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
+     * **/
+    getTopicInformation: (topics: Array<Topic>) => Promise<Array<TopicInformation>>;
+    /***
+     * Get next page of topic activities
+     *
+     * **/
+    getTopicActivitiesNextPage: (nextPageToken: TopicFilterPagingToken) => Promise<TopicFilterPagedResult>;
+    /***
+     * Get next page of activities
+     *
+     * **/
+    getActivitiesNextPage: (nextPageToken: ActivityFilterPagingToken) => Promise<ActivityFilterPagedResult>;
+}

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

@@ -0,0 +1,15 @@
+import { Variation, VariationCreationRequest } from "../models";
+import { GuidValue } from "@omnia/fx-models";
+export declare class VariationService {
+    private httpClient;
+    static appIdQuery: {};
+    static obsoleteSetWCMApp(appId: GuidValue): void;
+    private readonly baseUrl;
+    create: (createRequest: VariationCreationRequest) => Promise<Variation>;
+    delete: (variation: Variation) => Promise<Variation>;
+    get: (publishingAppIds?: GuidValue[]) => Promise<{
+        [appId: string]: Variation[];
+    }>;
+    update: (variation: Variation) => Promise<Variation>;
+    updateVariationRouteChange: () => Promise<boolean>;
+}

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

@@ -0,0 +1,15 @@
+import { PageId } from "@omnia/wcm/models";
+import { YammerGroup } from "../models/yammer/YammerGroup";
+import { YammerTracking } from "../models/yammer/YammerTracking";
+export declare class YammerService {
+    private httpClient;
+    private omniaContext;
+    readonly baseUrl = "api/yammer";
+    getGroups: () => Promise<Array<YammerGroup>>;
+    isYammerTokenSetupAsync: () => Promise<boolean>;
+    ensureYammerPostCreation: (sourcePageId: number) => Promise<YammerTracking[]>;
+    getYammerTrackingOnPage: (pageId: PageId) => Promise<YammerTracking>;
+    disconnectYammerOnPage: (pageId: PageId) => Promise<void>;
+    connectPageToYammerPost: (pageId: PageId, yammerThreadId: number) => Promise<YammerTracking>;
+    ensureYammerLikesOfPage: (topicId: string, yammerThreadId: number) => Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+export * from "./NavigationService";
+export * from "./PageService";
+export * from "./PageQueryService";
+export * from "./DocumentService";
+export * from "./VariationService";
+export * from "./CalendarService";
+export * from "./PublishingRuleService";
+export * from "./PagePermissionService";
+export * from "./TopicActivityService";
+export * from "./NewsletterService";
+export * from "./ParticipantService";
+export * from "./EventService";
+export * from "./AutomaticPageCreationService";
+export * from "./ReusablePageService";
+export * from "./PageHiddenService";
+export * from "./ChannelManagementService";
+export * from "./YammerService";
+export * from "./PageStatisticsService";
+export * from "./PublishingChannelCategoriesService";
+export * from "./AiContentPageReportService";
+export * from "./OpenAIPageCreationService";
+export * from "./OmniaSearchPageService";

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

@@ -0,0 +1,32 @@
+import { PagedBatchSearchRequest } from "@omnia/fx-models";
+import { EnterprisePropertyStore } from "@omnia/fx/stores";
+import { BatchQueryPages } from "../models";
+import { PublishingAppInfoStore } from "../stores";
+export declare class OmniaSearchQueryHelper {
+    enterprisePropertyStore: EnterprisePropertyStore;
+    publishingAppInfoStore: PublishingAppInfoStore;
+    private enterpriseProperties;
+    private querableProperties;
+    private publishingAppInfos;
+    generatePagedBatchSearchRequest(queries: BatchQueryPages[]): Promise<{
+        searchQueryRequest: PagedBatchSearchRequest;
+        batchQueryPagesError: BatchQueryPages[];
+    }>;
+    static camelize(str: string): string;
+    private hasBusinessProfileScopeQuery;
+    private getSearchBoxKeywords;
+    private getFilterExpressionString;
+    private getSingleValueOperatorString;
+    private getContainsOperatorString;
+    private getFiltersExpressionString;
+    private getFieldValuesString;
+    private getOperatorString;
+    private getPropertyName;
+    private getPropertyValue;
+    private getLogicalOperatorString;
+    private removeConditionExpressionFilter;
+    private getRetrieveProperties;
+    private isDateTimeStampProperty;
+    private getSortList;
+    private parseBatchQueryPagesToOmniaSearch;
+}

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

@@ -0,0 +1,217 @@
+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, UIQueryFilter } 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 pageSearchHelper;
+    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 profileCardStore;
+    private resolvablePageRollupInNP;
+    private pageRollupInstancesInNP;
+    private pageRollupInstances;
+    private notificationPanelInstances;
+    private taxonomyPropertySettings;
+    private tagsProperties;
+    private tagsPropertySettings;
+    private contentProperties;
+    private initialDataResolvable;
+    private _pageBlockPropertyStore;
+    private currentIdentity;
+    private currentResolvedIdentity;
+    private cancelBatchQueryTokens;
+    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, uiQueryFilter: UIQueryFilter, orderBy?: Array<QueryOrder>, blockProperty?: ReactivePageBlockProperty<PageRollupBlockProperty>, forceExecuteQuery?: boolean, clientCaching?: boolean, showMetric?: boolean): Promise<void>;
+    getRollupId(blockInstance: IBlockInstance<PageRollupBlockSettings>): string;
+    setLoadedPageRollups(pageRollupQueryId: string, isDestroyed: boolean): void;
+    private getPagingQuery;
+    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();
+    renewPageBlockPropertyStore(): void;
+    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[];
+    renewPageBlockPropertyStore(): void;
+    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(): Promise<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 generateUIQueryFilter;
+    private generateQueryablePropertyName;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { ChannelManagementStore, PageRollupStore } from "..";
+import { BatchQueryPages, BatchQueryPagesResult } from "../models";
+import { OmniaSearchQueryHelper } from "./OmniaSearchQueryHelper";
+import { EnterprisePropertyStore, FeatureStore, MultilingualStore } from "@omnia/fx/stores";
+export declare class PageSearchHelper {
+    private pageQueryService;
+    private omniaSearchPageService;
+    channelManagementStore: ChannelManagementStore;
+    multilingualStore: MultilingualStore;
+    enterprisePropertyStore: EnterprisePropertyStore;
+    omniaSearchQueryHelper: OmniaSearchQueryHelper;
+    featureStore: FeatureStore;
+    pageRollupStore: PageRollupStore;
+    private static outOfScopeOmniaSearchProperties;
+    queryBatchPages(queries: BatchQueryPages[], cancelRequest?: (cancelToken: any) => void): Promise<BatchQueryPagesResult>;
+    private getOutOfScopeOmniaSearchQueries;
+    private hasOutOfScopeOmniaSearchPropertiesInFilter;
+    private ensureQueryPageRollupInOmniaSearch;
+    private trimDuplicateBatchResults;
+    private processPagesDetailData;
+    private getUniquePageDetails;
+    private mapProperties;
+}

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

@@ -0,0 +1,3 @@
+export * from "./PageRollupStoreHelper";
+export * from "./PageSearchHelper";
+export * from "./OmniaSearchQueryHelper";

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

@@ -0,0 +1,19 @@
+import { ThemeStyling } from "@omnia/fx/models";
+import { Store } from "@omnia/fx/stores";
+export declare class ActivityFeedStore extends Store {
+    private themeStyling;
+    private customStyling;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    getters: {
+        themeStyling: () => ThemeStyling;
+        customStyling: () => boolean;
+    };
+    /**
+     * 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>;
+    };
+    actions: {};
+}