@omnia/wcm 8.0.1-dev → 8.0.2-dev

package/internal-do-not-import-from-here/fx/apis/ChannelRollup.d.ts

@@ -0,0 +1,18 @@
+import { ApiPath } from "@omnia/fx/models";
+import { ChannelRollupBlockStyles, ChannelRollupRegistrationView } from "@omnia/wcm/models";
+export interface IChannelRollupRegistrationApi {
+    registerViews: (views: ChannelRollupRegistrationView | ChannelRollupRegistrationView[]) => void;
+}
+declare module "./WcmApi" {
+    interface IWCMApi {
+        channelRollup: {
+            styles: Promise<typeof ChannelRollupBlockStyles>;
+            registration: Promise<IChannelRollupRegistrationApi>;
+        };
+    }
+    interface IWCMExtendApiManifest {
+        channelRollup: {
+            registration: ApiPath;
+        };
+    }
+}

package/internal-do-not-import-from-here/fx/apis/Fx.d.ts

@@ -0,0 +1,19 @@
+import * as WcmModels from "../models";
+import * as Routing from "../routing";
+import * as WcmService from "../services";
+import * as Stores from "../stores";
+import * as Helpers from "../helpers";
+import * as Factory from "../factory";
+import * as Translator from "../translator";
+import * as Context from "../contexts";
+import * as Messageing from "../messaging";
+import * as Constant from "../constants";
+import * as Rule from "../rules";
+type WcmFxApi = typeof Routing & typeof WcmService & typeof Stores & typeof Helpers & typeof Factory & typeof Translator & typeof Context & typeof Messageing & typeof Constant & typeof Rule;
+declare module "./WcmApi" {
+    interface IWCMApi {
+        fx: Promise<WcmFxApi>;
+        models: Promise<typeof WcmModels>;
+    }
+}
+export {};

package/internal-do-not-import-from-here/fx/apis/PageRollup.d.ts

@@ -0,0 +1,18 @@
+import { ApiPath } from "@omnia/fx/models";
+import { PageRollupBlockStyles, PageRollupRegistrationView } from "@omnia/wcm/models";
+export interface IPageRollupRegistrationApi {
+    registerViews: (views: PageRollupRegistrationView | PageRollupRegistrationView[]) => void;
+}
+declare module "./WcmApi" {
+    interface IWCMApi {
+        pageRollup: {
+            styles: Promise<typeof PageRollupBlockStyles>;
+            registration: Promise<IPageRollupRegistrationApi>;
+        };
+    }
+    interface IWCMExtendApiManifest {
+        pageRollup: {
+            registration: ApiPath;
+        };
+    }
+}

package/internal-do-not-import-from-here/fx/apis/WcmApi.d.ts

@@ -0,0 +1,12 @@
+export interface IWCMApi {
+}
+export interface IWCMExtendApiManifest {
+}
+declare module "@omnia/fx-models/Extends" {
+    interface IExtend {
+        wcm: IWCMApi;
+    }
+    interface IExtendApiManifest {
+        wcm: IWCMExtendApiManifest;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./Fx";
+export * from "./PageRollup";
+export * from "./ChannelRollup";
+export * from "./WcmApi";

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

@@ -0,0 +1,149 @@
+import { ActionHandlerRegistrationId, Guid } from "@omnia/fx-models";
+import { CalendarViewWeekdaysValue, LinkPickerRegistration } from "./models";
+export declare const TopicPrefixConstants: {
+    readonly pageCollection: string;
+    readonly page: string;
+};
+export declare const PublishingAppDefaultScrollElementClass = "owmc-scroll-d85cda66-c6b5-4515-b6b4-536b11e58d14";
+export declare const OmniaWCMPageBody: string;
+export declare const VisitedPageKeyPrefix = "owcm.visitedpage";
+export declare const PublishingAppUniqueModelName = "owcmpublishingappid";
+export declare const GovernanceDashboard: {
+    scopePageId: Guid;
+    scopeUserActivity: Guid;
+    scopeUrlId: Guid;
+    Filters: {
+        PublishingApps: Guid;
+        PageTypes: Guid;
+        UserProperties: Guid;
+    };
+    Metrics: {
+        PublishedId: Guid;
+        WaitingApprovalId: Guid;
+        DraftId: Guid;
+        NoCommentsId: Guid;
+        AverageCommentsIds: Guid;
+        AverageRatingsId: Guid;
+        ReachId: Guid;
+        UnderuserdId: Guid;
+        ActiveUserReader: Guid;
+        ActiveUserContributor: Guid;
+        LinkStatusNotFoundId: Guid;
+        LinkStatusUnauthorizedId: Guid;
+    };
+    Properties: {
+        ReachFieldId: Guid;
+        VariationsFieldId: Guid;
+        PageHitsId: Guid;
+        UniqueVisitors: Guid;
+        PublishDate: Guid;
+    };
+};
+export declare const BuiltInActionButtonHandlers: {
+    LinkButton: ActionHandlerRegistrationId;
+    MySubscriptions: ActionHandlerRegistrationId;
+    Subscribe: ActionHandlerRegistrationId;
+    CreatePage: ActionHandlerRegistrationId;
+    Event: ActionHandlerRegistrationId;
+    InviteCoAuthors: ActionHandlerRegistrationId;
+    AddToMyCalendar: ActionHandlerRegistrationId;
+};
+export declare const WCMPageKeyPrefix: {
+    page: string;
+    block: string;
+};
+export declare const WCMPageVersionStateException: {
+    alreadyCheckedout(pageId: any): string;
+};
+export declare const EnterprisePropertyInternalNames: {
+    Title: string;
+    StartDate: string;
+    EndDate: string;
+    ReservationOnly: string;
+    EnableStandbyList: string;
+    SignUpColleague: string;
+    MaxParticipants: string;
+    RegistrationStartDate: string;
+    RegistrationEndDate: string;
+    CancellationEndDate: string;
+    IsOnlineMeeting: string;
+    OnlineMeetingUrl: string;
+};
+export declare const ParticipantsFields: {
+    displayName: string;
+    email: string;
+    status: string;
+    capacity: string;
+    actions: string;
+};
+export declare const TimeFormat = "HH:mm";
+export declare const OutlookEvent: {
+    new (): {};
+    Attendee: {
+        new (): {};
+        Type: {
+            new (): {};
+            Required: string;
+            Optional: string;
+        };
+        Status: {
+            new (): {};
+            Response: {
+                new (): {};
+                None: string;
+                Accepted: string;
+                Declined: string;
+                NotResponded: string;
+            };
+        };
+    };
+};
+export declare const PageRollupListView: {
+    RegisteredCapacityInternalName: string;
+    LeftCapacityInternalName: string;
+};
+export declare const PageRollupIndexedDB: {
+    PageRollupsObjectNameDatabase: string;
+    PageRollupsValuePath: string;
+    PageRollupsKeyPath: string;
+};
+export declare const MaxIntNumber = 2147483647;
+export declare const EmailSettingsKey = "omniax.event.management.email.settings";
+export declare const EventParticipantListElementName = "omx-em-event-participant-list";
+export declare const QueryableProperties: {
+    TableNames: {
+        PageQueryData: string;
+    };
+};
+export declare const LinkPickerProviders: {
+    customlink: string;
+    linkPage: string;
+    document: string;
+};
+export declare const LinkPickerProviderMsg: {
+    getCustomLinkProvider: () => LinkPickerRegistration;
+    getLinkPageProvider: () => LinkPickerRegistration;
+    getDocumentLinkProvider: () => LinkPickerRegistration;
+};
+export declare const LayoutDataParentPageId = "LayoutDataParentPageId";
+export declare const CalendarConstants: {
+    SunSat: {
+        value: number[];
+        viewStartOffset: number[];
+        viewEndOffset: number[];
+    };
+    MonSun: {
+        value: number[];
+        viewStartOffset: number[];
+        viewEndOffset: number[];
+    };
+    MonFri: {
+        value: number[];
+        viewStartOffset: number[];
+        viewEndOffset: number[];
+    };
+    getByValue: (value: Array<number>) => CalendarViewWeekdaysValue;
+};
+export declare const PageApprovalConstants: {
+    FakeDefaultFirstStepId: Guid;
+};

package/internal-do-not-import-from-here/fx/contexts/WcmContext.d.ts

@@ -0,0 +1,8 @@
+import { WcmRouteContext, IWcmContext, VariationId } from "../models";
+import { IMessageBusTopicSubscription } from "@omnia/fx-models";
+export declare class WcmContext implements IWcmContext {
+    private provider;
+    onContextChanged(): IMessageBusTopicSubscription<IWcmContext>;
+    get routeContext(): Promise<WcmRouteContext>;
+    get variationId(): VariationId;
+}

package/internal-do-not-import-from-here/fx/contexts/WcmContextProvider.d.ts

@@ -0,0 +1,9 @@
+import { IMutableContextProvider } from "@omnia/fx/models";
+import { IWcmContext, VariationId } from "../models";
+export interface IWcmMutableContextProvider extends IMutableContextProvider<IWcmContext> {
+    setVariationId(id: VariationId): void;
+}
+export declare class WcmContextProvider {
+    private static _instance;
+    static get instance(): IWcmMutableContextProvider;
+}

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

@@ -0,0 +1 @@
+export * from "./WcmContext";

package/internal-do-not-import-from-here/fx/contexts/wcm.contexts.manifest.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/docs/docs.manifest.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/docs/nav.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/docs/wcm-buttonlink-view.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/docs/wcm-link-picker.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/factory/ActivityActionFactory.d.ts

@@ -0,0 +1,9 @@
+import { ActivityAction } from "../models";
+import { WCMCoreLocalization } from "../../core";
+/**
+ * Factory for Layout items
+ * */
+export declare class ActivityActionFactory {
+    static loc: WCMCoreLocalization.locInterface;
+    static createDefault(): Array<ActivityAction>;
+}

package/internal-do-not-import-from-here/fx/factory/BreakPointFactory.d.ts

@@ -0,0 +1,8 @@
+import { WCMCoreLocalization } from "../../core";
+import { DisplayBreakPoint } from "@omnia/fx-models";
+export declare class DisplayBreakPointFactory {
+    private static breakPointArray;
+    static loc: WCMCoreLocalization.locInterface;
+    static emailBreadPoint(): DisplayBreakPoint;
+    static breakPoints(): Array<DisplayBreakPoint>;
+}

package/internal-do-not-import-from-here/fx/factory/PageFactory.d.ts

@@ -0,0 +1,27 @@
+import { Layout, MultilingualString } from "@omnia/fx-models";
+import { PageCollectionData, PageTypeData, PlainPageData, PageId } from "../models";
+import { PageService } from "../services/PageService";
+import { EnterprisePropertyStore } from "@omnia/fx/stores";
+import { OmniaContext } from "@omnia/fx";
+/**
+ * Factory for Layout items
+ * */
+export declare class PageFactory {
+    static pageService: PageService;
+    static enterprisePropertyStore: EnterprisePropertyStore;
+    static omniaContext: OmniaContext;
+    static ensurePageCollectionData(pageCollectionData: PageCollectionData): PageCollectionData;
+    static createPageCollection(title: string, layout: Layout): PageCollectionData;
+    static createPageType(title: MultilingualString, layout: Layout): PageTypeData;
+    static createPlainPage(title: string, propertyValues: {
+        [internalName: string]: any;
+    }, inheritFromPageTypeId?: PageId): Promise<PlainPageData>;
+    static getKeyValuesDefaultPropertiesToPage(pageTypeData: PageTypeData): Promise<{
+        [internalName: string]: any;
+    }>;
+    static ensureCalculatedProperties(properties: {
+        [internalName: string]: any;
+    }, pageTypeData: PageTypeData, isCreate: boolean, inheritedProperties?: {
+        [internalName: string]: unknown;
+    }): void;
+}

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

@@ -0,0 +1,3 @@
+export * from "./PageFactory";
+export * from "./BreakPointFactory";
+export * from "./ActivityActionFactory";

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

@@ -0,0 +1 @@
+export * from "./pagerollup";

package/internal-do-not-import-from-here/fx/filterengine/pagerollup/PageRollupFilterEngineContext.d.ts

@@ -0,0 +1,7 @@
+import { DbQueryFilterEngineContext } from "@omnia/fx-models";
+export declare class PageRollupFilterEngineContext extends DbQueryFilterEngineContext {
+    componentId: string;
+    uniqueId: string;
+    constructor(componentId: string);
+    getAvailableProperties(): import("@omnia/fx-models").EnterprisePropertyDefinition[];
+}

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

@@ -0,0 +1 @@
+export * from "./PageRollupFilterEngineContext";

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

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/fx/helpers/BackgroundImageHelper.d.ts

@@ -0,0 +1,8 @@
+import { WCMBackgroundSettings } from "../models";
+import { CurrentPageStore } from "..";
+export declare class BackgroundImageHelper {
+    /**
+    * Loads the page image from the enterprise properties
+    * */
+    static ensureBackgroundImage(backgroundSettings: WCMBackgroundSettings, currentPageStore: CurrentPageStore): void;
+}

package/internal-do-not-import-from-here/fx/helpers/ItemQueryHelper.d.ts

@@ -0,0 +1,32 @@
+import { EnterprisePropertyDefinition, GuidValue, Tag, Identity } from "@omnia/fx-models";
+import { ItemQueryEnums, QueryFilter, PageId, VariationId } from "../models";
+export declare module ItemQueryHelper {
+    const PageId = "PId";
+    const ConditionExpressionFilter = "ConditionExpressionFilter";
+    const VariationId = "VariationId";
+    function generateExcludePageId(logicalOperator: ItemQueryEnums.FilterLogicalOperator, pageId: PageId, filters?: Array<QueryFilter>): QueryFilter;
+    function generateFalseFilter(logicalOperator: ItemQueryEnums.FilterLogicalOperator, filters?: Array<QueryFilter>): QueryFilter;
+    function generateTrueFilter(logicalOperator: ItemQueryEnums.FilterLogicalOperator, filters?: Array<QueryFilter>): QueryFilter;
+    function generateTextEqualFilter(property: string, text: string, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateTextFilter(property: string, text: string, logicalOperator: ItemQueryEnums.FilterLogicalOperator, enableWildcardSearch: boolean): QueryFilter;
+    function generateProcessFilterValue(property: string, text: string, logicalOperator: ItemQueryEnums.FilterLogicalOperator, enableWildcardSearch: boolean): QueryFilter;
+    function generateProcessFilter(property: string, processIdsArray: Array<string>, logicalOperator: ItemQueryEnums.FilterLogicalOperator, enableWildcardSearch: boolean): QueryFilter;
+    function generateEmptyArrayFilter(property: string, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generatePersonFilter(property: string, values: Array<Identity>, includeEmpty: boolean, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateQueryablePropertyName(internalName: string): {
+        internalName: string;
+        isComputedColumn: boolean;
+    };
+    function generateTaxonomyFilter(property: string, termIds: Array<GuidValue>, includeEmpty: boolean, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateTagFilter(property: string, value: Array<Tag>, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateVariationPropertyFilter(values: Array<VariationId>, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generatePageComputedColumnName(internalName: string): string;
+    function generatePagePropertyInternalName(property: EnterprisePropertyDefinition): string;
+    function getContentPropertyInternalName(pagePropertyInternalName: string): string;
+    function mapToPageProperty(property: EnterprisePropertyDefinition): EnterprisePropertyDefinition;
+    function generateNumberFilter(property: string, value: number, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateBooleanFilter(property: string, value: boolean, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateDateFilter(property: string, from: Date, to: Date, logicalOperator: ItemQueryEnums.FilterLogicalOperator, keepTime?: boolean): QueryFilter;
+    function generateBitwiseFilter(property: string, value: number, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+    function generateIsNullFilter(property: string, logicalOperator: ItemQueryEnums.FilterLogicalOperator): QueryFilter;
+}

package/internal-do-not-import-from-here/fx/helpers/LayoutHelper.d.ts

@@ -0,0 +1,6 @@
+import { LayoutItem } from "@omnia/fx-models";
+export declare module LayoutHelper {
+    function registerBlockChangesAffectPagesChecker(elem: string, checker: (oldVal: any, newVal: any) => boolean): void;
+    function checkBlockChangesAffectPages(layoutItem: LayoutItem, getLatestPublishedBlockData: (key: string) => any, getComingPublishedBlockData: (key: string) => any): boolean;
+    function convertToPlainText(html: string): string;
+}

package/internal-do-not-import-from-here/fx/helpers/LayoutTemplateHelper.d.ts

@@ -0,0 +1,10 @@
+import { Layout, LayoutItem, Block } from "@omnia/fx-models";
+export declare class LayoutTemplateHelper {
+    static copyBlockSettingsFromCurrentSettings(currentLayout: Layout, templateLayout: Layout, elementName: any, settingCopier: (fromSettings: any, toSettings: any) => void): void;
+    static getBlocksInLayoutByType(layoutItem: LayoutItem, elementName: any): Array<Block>;
+    /**
+     * Get a block by name
+     * @param blockName the name of the block
+     */
+    static getBlockByName(container: LayoutItem, elementName: string): LayoutItem;
+}

package/internal-do-not-import-from-here/fx/helpers/NavigationNodeHelper.d.ts

@@ -0,0 +1,20 @@
+import { NavigationNode, NavigationData, NavigationNodeType } from "../models";
+export interface UrlData {
+    url: string;
+    openNewWindow: boolean;
+    isInternalUrl: boolean;
+    msTeamsUrl?: string;
+}
+export declare class NavigationNodeHelper {
+    private static currentPageStore;
+    private static variationsStore;
+    private static publishingAppInfoStore;
+    private static previewMode;
+    static get showHiddenNode(): boolean;
+    static filter(nodes: Array<NavigationNode<NavigationData>>, types: Array<NavigationNodeType>, published: boolean): Array<NavigationNode<NavigationData>>;
+    static filterPublishedNavigationNode(nodes: Array<NavigationNode<NavigationData>>): Array<NavigationNode<NavigationData>>;
+    static filterMegaMenuPublishedNavigationNode(nodes: Array<NavigationNode<NavigationData>>): Array<NavigationNode<NavigationData>>;
+    static filterCurrentNavigationPublishedNavigationNode(nodes: Array<NavigationNode<NavigationData>>): Array<NavigationNode<NavigationData>>;
+    static getUrlForMSTeams(node: NavigationNode<NavigationData>): string;
+    private static getVariationSegment;
+}

package/internal-do-not-import-from-here/fx/helpers/PageNavigationNodeHelper.d.ts

@@ -0,0 +1,10 @@
+import { PageNavigationData, PageNavigationNode, PageId } from "../models";
+export declare class PageNavigationNodeHelper {
+    /**
+    * Check whether that node contains page (default page and variation page in dictionary) from a provided pageid
+    * @param node : node to check
+    * @param pageId : pageId that need to look for
+    * @Return : true if found , false : not found
+    */
+    static hasNodeContainsPage(node: PageNavigationNode<PageNavigationData>, pageId: PageId): boolean;
+}

package/internal-do-not-import-from-here/fx/helpers/PageRedirectHelper.d.ts

@@ -0,0 +1,7 @@
+import { PageNavigationData, PageNavigationNode } from "../models";
+export declare class PageRedirectHelper {
+    private static wcmContext;
+    private static variationsStore;
+    private static publishingAppInfoStore;
+    static getUrl(node: PageNavigationNode<PageNavigationData>): string;
+}

package/internal-do-not-import-from-here/fx/helpers/PageVariationHelper.d.ts

@@ -0,0 +1,27 @@
+import { PageNavigationData, PageNavigationNode, VariationPage, VariationId } from "../models";
+export declare class PageVariationHelper {
+    private static wcmContext;
+    private static variationsStore;
+    /**
+     * Get all variation page (in dictionary) from a provided node
+     * @param node : node to get variation page
+     * @param includeDefaultPage : include the default page to the result if set as True
+     * @return : Array of variation pages
+     */
+    static getPageVariations(node: PageNavigationNode<PageNavigationData>, includeDefaultPage?: boolean): Array<VariationPage>;
+    /**
+     * Get page from navigation node by Variation Id
+     *
+     * if page match with variationid :
+     *      - return variation page
+     * if not using variation :
+     *      - return default page
+     * otherwise :
+     *      - return null
+     * @param node : node to find variation page
+     * @param variationId : variation id of the variation page needed
+     * @return VariationPage
+     */
+    static getPageByVariationId(node: PageNavigationNode<PageNavigationData>, variationId: VariationId): VariationPage;
+    static getCurrentPage(node: PageNavigationNode<PageNavigationData>, targetVariationId?: VariationId): VariationPage;
+}

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

@@ -0,0 +1,7 @@
+export * from "./ItemQueryHelper";
+export * from "./NavigationNodeHelper";
+export * from "./LayoutHelper";
+export * from "./BackgroundImageHelper";
+export * from "./PageVariationHelper";
+export * from "./PageNavigationNodeHelper";
+export * from "./PageRedirectHelper";

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

@@ -0,0 +1,13 @@
+export * from "./apis";
+export * from "./routing";
+export * from "./services";
+export * from "./stores";
+export * from "./helpers";
+export * from "./factory";
+export * from "./translator";
+export * from "./contexts";
+export * from "./messaging";
+export * from "./constants";
+export * from "./rules";
+export * from "./pages";
+export * from "./filterengine";

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

@@ -0,0 +1,3 @@
+export * from "./models";
+export * from "./services";
+export * from "./stores";

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

@@ -0,0 +1,16 @@
+import { NavigationData, NavigationNode } from "../../models";
+export declare enum BreadcrumNodeTypes {
+    NavigationNode = 0,
+    Link = 1
+}
+export interface BreadcrumNode {
+    nodeType: BreadcrumNodeTypes;
+}
+export interface BreadcrumNavigationNode extends BreadcrumNode {
+    navigationNode: NavigationNode<NavigationData>;
+}
+export interface BreadcrumLinkNode extends BreadcrumNode {
+    title: string;
+    url: string;
+    msTeamsUrl?: string;
+}

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

@@ -0,0 +1,31 @@
+import { Identity } from "@omnia/fx-models";
+export declare enum ReindexContentOmniaSearchStatus {
+    Unassigned = 0,
+    Assigned = 1,
+    Success = 2,
+    Exception = 3
+}
+export interface ReindexContentOmniaSearchProgress {
+    total: number;
+    failed: number;
+    description: string;
+    succeed: number;
+    appsProgress: {
+        [publishingAppId: string]: ReindexContentOmniaSearchAppProgress;
+    };
+}
+export interface ReindexContentOmniaSearchAppProgress {
+    failed: number;
+    succeed: number;
+}
+export interface ReindexContentOmniaSearch {
+    id: number;
+    status: ReindexContentOmniaSearchStatus;
+    createdAt: string;
+    createdBy: Identity;
+    modifiedAt: string;
+    modifiedBy: Identity;
+    error?: string;
+    resourceId?: string;
+    progress?: ReindexContentOmniaSearchProgress;
+}

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

@@ -0,0 +1,4 @@
+export interface PageTitleConfig {
+    title: string;
+    hideTitle: boolean;
+}

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

@@ -0,0 +1,93 @@
+import { FilterValue, DashboardMetricSettings } from "@omnia/workplace/models";
+import { Guid, EnterprisePropertyDefinition, QueryFilter } from "@omnia/fx-models";
+import { UnderusedSettings, PageId } from "@omnia/wcm/models";
+import { PageDashboardMetric } from "./PagesDashboardMetric";
+export declare enum PagesDashboardQueryTypes {
+    Published = 0,
+    Draft = 1,
+    WaitingApproval = 2,
+    PassedReviewDate = 3,
+    Archived = 4,
+    NoComments = 5,
+    HasBestReply = 6,
+    AverageNumberOfComments = 7,
+    AverageRatings = 8,
+    HaveRating = 9,
+    Reach = 10,
+    UnderusedContent = 11
+}
+export declare class PageTypesFilterValue extends FilterValue {
+    filterId: Guid;
+    value: PageId;
+}
+export declare class PublishingAppsFilterValue extends FilterValue {
+    filterId: Guid;
+    value: string;
+}
+export declare class UserPropertiesFilterValue extends FilterValue {
+    filterId: Guid;
+    propertyName: string;
+    value: string[];
+}
+export declare class PagesDashboardMetricQuery {
+    id: string;
+    queryType: PagesDashboardQueryTypes;
+    publishingAppId?: string;
+    pageTypeId?: number;
+    showHiddenPages: boolean;
+    settings: PageDashboardMetricSettings;
+}
+export interface PageDashboardMetricSettings {
+}
+export interface PageDashboardReachSettings extends PageDashboardMetricSettings {
+    targetNoOfUsers: number;
+    months: Array<Date>;
+}
+export interface PageDashboardUnderusedSettings extends PageDashboardMetricSettings {
+    pageHitsPerMonth: number;
+    uniqueVisitorsPerMonth: number;
+    months: Array<Date>;
+}
+export declare class PagesDetailDashboardQuery {
+    skip?: number;
+    itemLimit?: number;
+    includeTotal: boolean;
+    enterprisePropertieInternalNames: string[];
+    metricQuery: PagesDashboardMetricQuery;
+    constructor();
+}
+export interface PagesDashboardIndicatorResult {
+    [id: string]: PageDashboardMetric;
+}
+export declare class PagesDashboardDetailResult {
+    items: PageDashboardDetail[];
+    total: number;
+    isLockingData: boolean;
+}
+export declare class PageDashboardDetail {
+    title: string;
+    id: PageId;
+    publishingAppId: Guid;
+    pageCollectionTitle?: string;
+    properties: {
+        [propertyInternalName: string]: any;
+    };
+}
+export interface PagesMetricConfig extends DashboardMetricSettings {
+    property: EnterprisePropertyDefinition;
+    showHiddenPages: boolean;
+}
+export interface PagesDashboardQueryParameters {
+    pageTypeId: number;
+    publishingAppId: string;
+}
+export interface PagesReachMetricConfig extends PagesMetricConfig {
+    targetNoOfUsers: number;
+}
+export interface PagesUnderusedMetricConfig extends PagesMetricConfig, UnderusedSettings {
+}
+export interface PagesDashboardByUserPropertiesRequest {
+    item: PageDashboardDetail;
+    filters: QueryFilter[];
+    queryType: PagesDashboardQueryTypes;
+}