@omnia/wcm 8.0.1-dev → 8.0.2-dev

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

@@ -0,0 +1,14 @@
+export * from "./Topic";
+export * from "./PageTopic";
+export * from "./PageCollectionTopic";
+export * from "./PublishingAppTopic";
+export * from "./TopicSubscription";
+export * from "./TopicWithFilter";
+export * from "./TopicInformation";
+export * from "./PublishingAppTopicInformation";
+export * from "./PageTopicInformation";
+export * from "./PageCollectionTopicInformation";
+export * from "./UserTopic";
+export * from "./TagTopic";
+export * from "./TaxonomyTopic";
+export * from "./PublishingChannelTopic";

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

@@ -0,0 +1,5 @@
+export * from "./Achievement";
+export * from "./ActivityAction";
+export * from "./Activities";
+export * from "./Topics";
+export * from "./CommentSearchResult";

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

@@ -0,0 +1,21 @@
+import { GuidValue, MultilingualString, IIcon, Language, Identity } from "@omnia/fx-models";
+import { TargetingFilterProperty } from "@omnia/fx-sp-models";
+/**
+ * This is no enum, it's the unique id (number) of the variation and generated serverside.
+ * */
+export declare enum VariationId {
+}
+export interface Variation {
+    id: VariationId;
+    displayNames: MultilingualString;
+    publishingAppId: GuidValue;
+    targetingFilterData: TargetingFilterProperty;
+    icon: IIcon;
+    urlSegment: string;
+    isDefault: boolean;
+    author: Identity;
+    supportedLanguages?: Array<Language>;
+    automaticMachineTranslation?: boolean;
+    allowEditMachineTranslation?: boolean;
+    activeRightToLeft?: boolean;
+}

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

@@ -0,0 +1,12 @@
+import { MultilingualString, IIcon, UserIdentity } from "@omnia/fx-models";
+import { TargetingFilterProperty } from "@omnia/fx-sp";
+export interface VariationCreationRequest {
+    displayNames: MultilingualString;
+    targetingFilterData: TargetingFilterProperty;
+    icon: IIcon;
+    urlSegment: string;
+    /**
+     * The principle/login of the user considered author
+     * */
+    author?: UserIdentity;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * A string abstraction mapping different string values to a specific variation id
+ *
+ * @example if(someProp.isVariationString){ alert('Current variation has value: ' + someProp[currentVaritionId] + ' for someProp')}
+ *
+ * */
+export interface VariationString {
+    /**
+     * A friendly marker to know that a string is a variation string
+     * New instances of this interface just sets this to true, (as it is a variation string).
+     * Used in code like:
+     * @example if(someProp.isVariationString){ //could be used as variationstring}
+     * */
+    isVariationString: true;
+    [variationId: number]: string;
+}

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

@@ -0,0 +1,3 @@
+export * from "./Variation";
+export * from "./VariationCreationRequest";
+export * from "./VariationString";

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

@@ -0,0 +1,39 @@
+export interface YammerGroup {
+    type: string;
+    id: number;
+    email: string;
+    full_name: string;
+    network_id: 11795691;
+    name: string;
+    description: string;
+    privacy: string;
+    url: string;
+    web_url: string;
+    mugshot_url: string;
+    mugshot_redirect_url: string;
+    mugshot_url_template: string;
+    mugshot_redirect_url_template: string;
+    mugshot_id: number;
+    show_in_directory: boolean;
+    created_at: string;
+    aad_guests: number;
+    color: string;
+    external: boolean;
+    moderated: boolean;
+    header_image_url: string;
+    category: string;
+    default_thread_starter_type: string;
+    restricted_posting: boolean;
+    company_group: boolean;
+    creator_type: string;
+    creator_id: number;
+    state: string;
+    stats: Stats;
+}
+export interface Stats {
+    members: number;
+    aad_guests: number;
+    updates: number;
+    last_message_id: number;
+    last_message_at: string;
+}

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

@@ -0,0 +1,42 @@
+export interface YammerMessage {
+    id: number;
+    sender_id: number;
+    delegate_id: number;
+    replied_to_id: number;
+    created_at: string;
+    network_id: number;
+    message_type: string;
+    sender_type: string;
+    url: string;
+    web_url: string;
+    group_id: number;
+    body: Body;
+    thread_id: number;
+    client_type: string;
+    client_url: string;
+    system_message: boolean;
+    direct_message: boolean;
+    language: string;
+    notified_user_ids: Array<number>;
+    privacy: string;
+    attachments: any[];
+    liked_by: LikeBy;
+    content_excerpt: string;
+    group_created_id: number;
+}
+export interface Body {
+    parsed: string;
+    plain: string;
+    rich: string;
+}
+export interface LikeBy {
+    count: number;
+    names: Array<number>;
+}
+export interface YammerMessagePost {
+    body: string;
+    replied_to_id?: number;
+    direct_to_user_ids?: Array<number>;
+    group_id?: number;
+    network_id?: number;
+}

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

@@ -0,0 +1,9 @@
+import { GuidValue } from "@omnia/fx/models";
+import { PageId } from "../pages";
+export interface YammerTracking {
+    id: GuidValue;
+    pageId: PageId;
+    yammerGroupId: number;
+    yammerThreadId: number;
+    businessProfileId: GuidValue;
+}

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

@@ -0,0 +1,12 @@
+import { IPageVersion, IVersionEnterpriseProperties, IVersionPropertyBag, PageData, VersionedPageData } from "../models";
+export declare class PageVersion implements IPageVersion {
+    private _versionData;
+    private versionEnterpriseProperties;
+    private versionPropertyBag;
+    private _isCheckedoutByCurrentUser;
+    constructor(_versionData: VersionedPageData<PageData>, versionForPropertyInheritance: VersionedPageData<PageData>, currentUserIdentity: string);
+    get versionData(): VersionedPageData<PageData>;
+    get enterpriseProperties(): IVersionEnterpriseProperties;
+    get propertyBag(): IVersionPropertyBag;
+    get isCheckedoutByCurrentUser(): boolean;
+}

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

@@ -0,0 +1,17 @@
+import { MessageBusTopicMediator } from "@omnia/fx";
+import { IVersionEnterpriseProperties, PageData, VersionedPageData } from "../models";
+export declare class VersionEnterpriseProperties implements IVersionEnterpriseProperties {
+    private _versionData;
+    private _versionInheritedFrom;
+    onPropertyUpdated: MessageBusTopicMediator<{
+        key: string;
+        value: any;
+    }>;
+    constructor(_versionData: VersionedPageData<PageData>, _versionInheritedFrom: VersionedPageData<PageData>);
+    inherited: (key: string) => boolean;
+    getValue: <T extends unknown>(key: string) => T;
+    setValue: (key: string, value: any) => void;
+    getOrSetInitialValue: <T extends unknown>(key: string, initialValueFactory: (inherited: boolean) => T) => T;
+    get keys(): Array<string>;
+    private get allEnterpriseProperties();
+}

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

@@ -0,0 +1,16 @@
+import { MessageBusTopicMediator } from "@omnia/fx";
+import { IVersionPropertyBag } from "../models";
+export declare class VersionPropertyBag implements IVersionPropertyBag {
+    private _bagData;
+    onPropertyUpdated: MessageBusTopicMediator<{
+        key: string;
+        value: any;
+    }>;
+    constructor(_bagData: {
+        [key: string]: any;
+    });
+    getValue: <T extends unknown>(key: string) => T;
+    setValue: (key: string, value: any) => void;
+    getOrSetInitialValue: <T extends unknown>(key: string, initialValueFactory: () => T) => T;
+    get keys(): Array<string>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./PageVersion";
+export * from "./VersionEnterpriseProperties";
+export * from "./VersionPropertyBag";

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

@@ -0,0 +1,38 @@
+import { NavigationData, NavigationNode } from "../models";
+export declare class WcmRouter {
+    private currentNavigationStore;
+    private currentPageStore;
+    private navigationStore;
+    private pagesStore;
+    private variationsStore;
+    private omniaCtx;
+    private wcmContext;
+    private publishingAppInfoStore;
+    private userTargetingStore;
+    private multilingualStore;
+    private isVariationSwitch;
+    private currentNavigatedState;
+    private loadTreeForPathPromises;
+    private initState;
+    constructor();
+    private isInWcmContext;
+    private handleNotFoundNavigationNode;
+    private getDefaultRoute;
+    private loadTreeForPath;
+    navigate<T extends NavigationNode<NavigationData>>(to: T, targetVariationId?: any): Promise<T>;
+    navigateWithVariationTargeting<T extends NavigationNode<NavigationData>>(to: T): Promise<T>;
+    private getTargetingVariation;
+    onDisposing(): void;
+    private executeScrollingIfNeeded;
+    private executeNewNavigationState;
+    private isSameNavigationState;
+    /**
+     * Create a state object contaning all parameters needed to navigate or null if node type not supported
+     *
+     * */
+    private createNavigationStateForNode;
+    private tryParseNumber;
+    private getPageTitle;
+    private getPageState;
+    private getUsingVariationSegment;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { FeatureStore } from "@omnia/fx/stores";
+export declare class CommunityRules {
+    static featureStore: FeatureStore;
+    /**
+     * Returns true if this is a community app
+     * */
+    static get isCommunityApp(): boolean;
+}

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

@@ -0,0 +1,3 @@
+export declare class EditingDisplayRules {
+    static isAdvancedModeActivated(): boolean;
+}

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

@@ -0,0 +1,13 @@
+import { NavigationData, NavigationNode } from "../models";
+import { Identity } from "@omnia/fx-models";
+export interface NavigationNodeIcon {
+    icon: string;
+    tooltip: string;
+}
+export declare class IconRules {
+    private static loc;
+    private static userIdentityStore;
+    private static resolvedUser;
+    static getPageIcon(navigationNode: NavigationNode<NavigationData>): NavigationNodeIcon;
+    static resolveUserIdentity(identity: Identity): void;
+}

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

@@ -0,0 +1,9 @@
+import { ITheming } from "@omnia/fx/ux";
+export declare class ThemingRules {
+    /**
+     * Rule if multilingual or single title should setting should be shown
+     * */
+    static isUsingDefaultBlockTheme(theme: ITheming): boolean;
+    static isUsingDefaultDialogTheme(theme: ITheming): boolean;
+    static isThemingActive(): boolean;
+}

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

@@ -0,0 +1,96 @@
+import { VariationStore } from "../stores/VariationStore";
+import { CurrentPageStore } from "../stores/CurrentPageStore";
+import { PagesStore } from "../stores/PagesStore";
+import { Page, PageId } from "../models";
+import { NavigationStore } from "../stores/NavigationStore";
+export declare class VariationRules {
+    static variationStore: VariationStore;
+    static currentPageStore: CurrentPageStore;
+    static pagesStore: PagesStore;
+    static navigationStore: NavigationStore;
+    /**
+     * Rule if multilingual or single title should setting should be shown
+     * */
+    static showOneLanguageTitle(): boolean;
+    /**
+     * Try to get a fallback page id of a page following the variation rules
+     *
+     * If no variation setup:
+     *      -return null, when the page is soft-deleted
+     *      -return the page id, when the page is NOT soft-deleted
+     *
+     * If variation setup:
+     *      -return null, when the original page is soft-deleted
+     *      -return original page id, when only the variation page is soft-deleted
+     *      -return variation page id, when the variation page is NOT soft-deleted
+     *
+     * @param page
+     */
+    static getFallbackNotSoftDeletedPageId(page: Page): PageId;
+    /**
+     * Try to get a fallback page of a page following the variation rules
+     *
+     * If no variation setup:
+     *      -return null, when the page is soft-deleted
+     *      -return the page, when the page is NOT soft-deleted
+     *
+     * If variation setup:
+     *      -return null, when the original page is soft-deleted
+     *      -return original page, when only the variation page is soft-deleted
+     *      -return variation page, when the variation page is NOT soft-deleted
+     *
+     *
+     * @param page
+     * @param returnThePageIfNoFallbackPage instead of return null, return the page
+     */
+    static getFallbackNotSoftDeletedPage(page: Page, returnThePageIfNoFallbackPage: boolean): Promise<Page>;
+    /**
+     * Try to get a fallback page id of a page following the variation rules
+     *
+     * If no variation setup:
+     *      -return null, when the page is hidden
+     *      -return the page id, when the page is NOT hidden
+     *
+     * If variation setup:
+     *      -return null, when the original page is hidden
+     *      -return original page id, when only the variation page is hidden
+     *      -return variation page id, when the variation page is NOT hidden
+     *
+     * @param page
+     */
+    static getFallbackNotHiddenPageId(page: Page): PageId;
+    /**
+     * Try to get a fallback page of a page following the variation rules
+     *
+     * If no variation setup:
+     *      -return null, when the page is hidden
+     *      -return the page, when the page is NOT hidden
+     *
+     * If variation setup:
+     *      -return null, when the original page is hidden
+     *      -return original page, when only the variation page is hidden
+     *      -return variation page, when the variation page is NOT hidden
+     *
+     *
+     * @param page
+     * @param returnThePageIfNoFallbackPage instead of return null, return the page
+     */
+    static getFallbackNotHiddenPage(page: Page, returnThePageIfNoFallbackPage: boolean): Promise<Page>;
+    /**
+     * Try to get a fallback page of a page following the variation rules
+     *
+     * If no variation setup:
+     *      -return null, when the page is hidden or soft-deleted
+     *      -return the page, when the page is NOT hidden and NOT soft-deleted
+     *
+     * If variation setup:
+     *      -return null, when the original page is hidden or soft-deleted
+     *      -return original page, when only the variation page is hidden or soft-deleted
+     *      -return variation page, when the variation page is NOT hidden and NOT soft-deleted
+     *
+     *
+     * @param inputPage
+     * @param returnThePageIfNoFallbackPage instead of return null, return the page
+     */
+    static getFallbackPage(inputPage: Page, returnThePageIfNoFallbackPage: boolean): Promise<Page>;
+}

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

@@ -0,0 +1,5 @@
+export * from "./VariationRules";
+export * from "./IconRules";
+export * from "./CommunityRules";
+export * from "./ThemingRules";
+export * from "./DisplayRules";

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

@@ -0,0 +1,17 @@
+import { PageAiAnalysisReport, PageAiAnalysisReportAddRequest, PageAiAnalysisReportQuery, PageAiAnalysisReportSummary, PageId, PageAiAnalysisReportDetails, AiAnalysisReportPageSnapshot } from "../models";
+import { PageAiAnalysisPropertyRequest } from "../models/aipagecontentreport/PageAiAnalysisPropertyRequest";
+export declare class AiContentPageReportService {
+    private httpClient;
+    private readonly baseUrl;
+    createNewReport: (request: PageAiAnalysisReportAddRequest) => Promise<PageAiAnalysisReport>;
+    getReport: (reportId: number) => Promise<PageAiAnalysisReport>;
+    getReportSummary: (reportId: any) => Promise<PageAiAnalysisReportSummary>;
+    getReportSummaries: (payload: PageAiAnalysisReportQuery) => Promise<Array<PageAiAnalysisReportSummary>>;
+    getReportDetails: (reportId: number) => Promise<PageAiAnalysisReportDetails>;
+    fixPage: (reportId: number, pageId: PageId) => Promise<void>;
+    getPageStatus: (reportId: number, pageId: PageId) => Promise<AiAnalysisReportPageSnapshot>;
+    getAnalyzeResult: (payload: PageAiAnalysisPropertyRequest) => Promise<{
+        [internalName: string]: any;
+    }>;
+    deleteReport: (reportId: number) => Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { PageId } from "@omnia/wcm/models";
+import { AutomaticPageCreationRequest } from "../models";
+export declare class AutomaticPageCreationService {
+    private httpClient;
+    private readonly baseUrl;
+    triggerProcessRequests: (sourcePageId: any) => Promise<void>;
+    ensureRequests: (sourcePageId: number) => Promise<AutomaticPageCreationRequest[]>;
+    automaticMachineTranslationPage: (defaultPageId: PageId) => Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { HttpClient } from "@omnia/fx";
+import { CalendarGroup, Calendar, EventCalendar, CalendarRollupFilter, Event, OfficeGroupCalendarRollupFilter, OutlookCalendarQuery, OutlookCalendar, OutlookGroupQuery, EventQueryResponse } from "@omnia/wcm/models";
+export declare class CalendarService {
+    protected httpClient: HttpClient;
+    constructor();
+    getCalendarGroups: () => Promise<CalendarGroup[]>;
+    getCalendarsByGroup: (groupId: string) => Promise<Calendar[]>;
+    searchEvents: (filter: CalendarRollupFilter) => Promise<Event[]>;
+    queryEvents: (filter: CalendarRollupFilter) => Promise<EventQueryResponse[]>;
+    queryNextEvents: (calendars: Array<Calendar>) => Promise<EventQueryResponse[]>;
+    searchOfficeGroupCalendar: (filter: OfficeGroupCalendarRollupFilter) => Promise<Calendar[]>;
+    copyToMyCalendar: (eventId: string) => Promise<Event>;
+    getEventById: (groupId: string, eventId: string) => Promise<Event>;
+    getCalendarByPageCollectionId: (pageCollectionId: number) => Promise<EventCalendar>;
+    addOrUpdateCalendar: (item: EventCalendar) => Promise<EventCalendar>;
+    getOutlookCalendars: (item: OutlookCalendarQuery) => Promise<Array<OutlookCalendar>>;
+    getOutlookGroups: (item: OutlookGroupQuery) => Promise<Array<OutlookCalendar>>;
+}

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

@@ -0,0 +1,26 @@
+import { TargetingFilterProperty } from "@omnia/fx-sp/models";
+import { GuidValue, Identity, MediaPickerImage, MultilingualString } from "@omnia/fx/models";
+import { PublishingChannel, PageId, UserAuthorizedChannelResources, ChannelPage, PublishingStatus, PublishingChannelId, PublishingChannelPage, ChannelRollupQuery, PublisingChannelQueryResult, PublishChannelPageRequest } from "../models";
+export declare class ChannelManagementService {
+    private httpClient;
+    constructor();
+    createPublishingChannel: (title: MultilingualString, description: MultilingualString, publicUrl: string, owner: Array<Identity>, image: MediaPickerImage, administrator: Array<Identity>, publisher: Array<Identity>, targetingFilter: TargetingFilterProperty, publishingCategoryId?: GuidValue) => Promise<PublishingChannel>;
+    updatePublishingChannel: (updateData: PublishingChannel) => Promise<PublishingChannel>;
+    getPublishingChannels: () => Promise<Array<PublishingChannel>>;
+    getRecentlyUsedChannels: () => Promise<PublishingChannel[]>;
+    getPublishingChannelById: (channelId: number) => Promise<PublishingChannel>;
+    getChannelPages: (pageId: PageId) => Promise<ChannelPage[]>;
+    getChannelsForPublishedPages: (pageIds: PageId[]) => Promise<{
+        [pageId: number]: PublishingChannelPage[];
+    }>;
+    deletePublishingChannel: (channelId: PublishingChannelId) => Promise<PublishingChannel>;
+    getUserPermissions: () => Promise<UserAuthorizedChannelResources>;
+    getChannelPagesByStatus: (status: PublishingStatus) => Promise<Array<ChannelPage>>;
+    approvePublishPageToChannel: (channel: PublishingChannel, pageId: PageId, pageTitle: string, pageUrl: string) => Promise<ChannelPage>;
+    rejectPublishPageToChannel: (channel: PublishingChannel, pageId: PageId, comment: string, pageTitle: string, pageUrl: string) => Promise<ChannelPage>;
+    addPageToChannels: (pageId: number, channelToPublishTo: Array<PublishChannelPageRequest>, defaultPublishingChannelId: PublishingChannelId) => Promise<Array<ChannelPage>>;
+    publishAddedPageToChannel: (pageId: PageId) => Promise<Array<ChannelPage>>;
+    publishPageToChannels: (pageId: number, channelToPublishTo: Array<PublishChannelPageRequest>, defaultPublishingChannelId: PublishingChannelId) => Promise<Array<ChannelPage>>;
+    queryChannelRollup: (query: ChannelRollupQuery) => Promise<Array<PublisingChannelQueryResult>>;
+    private mappingPublishingChannel;
+}

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

@@ -0,0 +1,8 @@
+import { DocumentQuery, DocumentQueryResult, UploadDocumentInfo, Document } from "../models";
+export declare class DocumentService {
+    private httpClient;
+    constructor();
+    getDocuments: (query: DocumentQuery) => Promise<DocumentQueryResult>;
+    upload: (fileInfo: UploadDocumentInfo) => Promise<Document>;
+    exists: (fileInfo: UploadDocumentInfo) => Promise<boolean>;
+}

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

@@ -0,0 +1,15 @@
+import { OmniaContext } from "@omnia/fx";
+import { EventDetail, EventClone, EventCloneResult, EventCapacity, OutlookEvent } from "../models";
+export declare class EventService {
+    omniaContext: OmniaContext;
+    private httpClient;
+    constructor();
+    getEventCapacities: (pageIds: Array<number>) => Promise<Array<EventCapacity>>;
+    ensureEvent: (eventItem: EventDetail) => Promise<EventDetail>;
+    getEvent: (pageId: number) => Promise<EventDetail>;
+    deleteEvent: (pageId: number) => Promise<EventDetail>;
+    cloneEvent: (eventItem: EventClone) => Promise<Array<EventCloneResult>>;
+    addOrUpdateOutlookEvent: (eventDetail: EventDetail) => Promise<EventDetail>;
+    addOrUpdatePersonalOutlookEvent: (pageId: number, ianaTimeZone: string) => Promise<EventDetail>;
+    getOutlookEvent: (pageId: number) => Promise<OutlookEvent>;
+}

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

@@ -0,0 +1,59 @@
+import { NavigationData, NavigationNode, NavigationResult, NodeId, NavigationPosition, MoveNavigationNodeResult, MovePageCollectionResult, PageId, PageNavigationData, PageNavigationNode, NavigationDataType, NavigationNodeQuery } from "../models";
+import { HttpClient } from "@omnia/fx";
+import { GuidValue } from "@omnia/fx-models";
+export declare class NavigationService {
+    protected httpClient: HttpClient;
+    protected readonly baseUrl = "api/navigation";
+    /**
+     *  /// <summary>
+        /// Creates a new navigation node of a defined type
+        /// Inserted under a supplied parent
+        /// Sorted between siblings, a combination of after/before
+        /// </summary>
+        /// <example>
+        /// Sort example
+        /// Last:
+        /// after:Null
+        /// before:Null
+        /// Result: last
+        ///
+        /// First:
+        /// after:Null
+        /// before:Current first
+        ///
+        /// Between:
+        /// after:Node on Index7
+        /// before:Node on Index 8
+        /// result: Between, new node will be child index8, previous 8 will be index 9
+        ///
+        /// Throws SortException if the current state does not match after/before supplied, i.e. concurrent change etc.
+        /// Throws Notfound exception if any of the nodes does not exist
+        /// </example>
+        /// <typeparam name="T">A type of NavigationData</typeparam>
+        /// <param name="nodeData">A navigation node of a certain type,
+        /// e.g. <see cref="PageNavigationData"/>/<see cref="NavigationData.WCMNavigationDataTypes.Page"/> or another custom type inheriting from <see cref="NavigationData"/></param>
+        /// <param name="parent">Null for root, or the parent under which to place the new node</param>
+     */
+    create: <T extends NavigationData>(nodeData: T, position: NavigationPosition) => Promise<NavigationNode<T>>;
+    /**
+     * Updates the data part of a navigation node i.e. NavigationNode.navigationData
+     **/
+    updateNodeData: <T extends NavigationNode<NavigationData>>(node: T) => Promise<T>;
+    move: <T extends NavigationNode<NavigationData>>(nodeToMove: T, newPosition: NavigationPosition) => Promise<MoveNavigationNodeResult>;
+    movePageCollection: (pageCollectionId: number, targetPublishingAppId: string) => Promise<MovePageCollectionResult>;
+    getParentNodes: <T extends NavigationNode<NavigationData>>(nodeToGetParentsFor: T, nodeTypes?: NavigationDataType) => Promise<Array<NavigationNode<NavigationData>>>;
+    getChildNodes: <T extends NavigationNode<NavigationData>>(nodeToGetParentsFor: T, nodeTypes?: NavigationDataType, depth?: number, forceFromPublishingAppId?: string) => Promise<Array<NavigationNode<NavigationData>>>;
+    getMegamenuChildNodes: <T extends NavigationNode<NavigationData>>(nodeToGetParentsFor: T, nodeTypes?: NavigationDataType, depth?: number, forceFromPublishingAppId?: string) => Promise<Array<NavigationNode<NavigationData>>>;
+    getMegamenusChildNodes: <T extends NavigationNode<NavigationData>>(nodesToGetParentsFor: NavigationNodeQuery<T>[], nodeTypes?: NavigationDataType) => Promise<Array<NavigationNode<NavigationData>>>;
+    getUnavailableDirectChildNodes: <T extends NavigationNode<NavigationData>>(nodeToGet: T) => Promise<Array<NavigationNode<NavigationData>>>;
+    getNodesByIds: (nodeIds: Array<NodeId>) => Promise<{
+        [nodeId: number]: NavigationNode<NavigationData>;
+    }>;
+    getNavigationByNode: (node: NavigationNode<NavigationData>, nodeTypes?: NavigationDataType) => Promise<NavigationResult>;
+    getNavigationByPath: (path: string, nodeTypes?: NavigationDataType) => Promise<NavigationResult>;
+    getNodesByPageIds: (...args: Array<PageId>) => Promise<{
+        [pageId: number]: PageNavigationNode<PageNavigationData>[];
+    }>;
+    deleteLinkNodeById: (id: NodeId) => Promise<void>;
+    checkUrlSegmentExists: (appInstanceId: GuidValue, parentNavigationNode: NavigationNode<NavigationData>, urlSegment: string) => Promise<boolean>;
+}

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

@@ -0,0 +1,8 @@
+import { VersionId, SendPageVersionPreviewMessage } from "../models";
+export declare class NewsletterService {
+    private httpClient;
+    constructor();
+    sendPagePreview(title: string, htmlContent: string, email: string): Promise<void>;
+    addOrUpdatePagePagePreviewHtml(htmlContent: string, pageVersionId: VersionId): Promise<void>;
+    sendPageVersionPreviewToRecipients(sendPageMessage: SendPageVersionPreviewMessage): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { PagedBatchSearchRequest, IPagedSearchResult } from "@omnia/fx-models";
+import { ExtendedInformationPageQueryData, PageDocument, PageId } from "../models";
+import { ReindexContentOmniaSearch } from "../internal";
+import { OmniaSearchService } from "@omnia/fx/services";
+export declare class OmniaSearchPageService {
+    private httpClient;
+    omniaSearchService: OmniaSearchService;
+    constructor();
+    queryBatchPages: (searchQueryRequest: PagedBatchSearchRequest, cancelRequest?: (cancelToken: any) => void) => Promise<IPagedSearchResult<PageDocument>[]>;
+    getExtendedInformationPageQueryData: (pageIds: Array<PageId>) => Promise<ExtendedInformationPageQueryData>;
+    triggerReindexContentOmniaSearchPublishingApp: () => Promise<string>;
+    triggerReindexContentOmniaSearchTenant: () => Promise<string>;
+    getReindexContentOmniaSearchStatus: (resourceId: string) => Promise<ReindexContentOmniaSearch>;
+    getReindexContentLogs: (resourceId: string, pageNr?: number, pageSize?: number, sortColumn?: string, sortDesc?: boolean) => Promise<{
+        total: number;
+        value: ReindexContentOmniaSearch[];
+    }>;
+}

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

@@ -0,0 +1,18 @@
+import { MediaPickerService } from "@omnia/fx/services";
+import { OpenAIPropertiesMapping, OpenAIPropertyMappingValue } from "../models";
+export declare class OpenAIPageCreationService {
+    private settingsService;
+    private openAIService;
+    mediaPickerService: MediaPickerService;
+    private enterprisePropertyStore;
+    constructor();
+    private contentPrompt;
+    private limitOutputLengthFromOpenAI;
+    private prefixSummaryPrompt;
+    createPageWithOpenAI(openAiPrompt: string, propertiesMapping: OpenAIPropertiesMapping, imagePrompt: string): Promise<OpenAIPropertyMappingValue>;
+    private handleResolution;
+    private getLimitSizeScalling;
+    private pollImage;
+    private validatePrompt;
+    private checkQueryableProperty;
+}

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

@@ -0,0 +1,7 @@
+import { PageId, PageHiddenResponse, NavigationNode, NavigationData } from "../models";
+export declare class PageHiddenService {
+    private httpClient;
+    private readonly baseUrl;
+    set: (pageId: PageId, node: NavigationNode<NavigationData>) => Promise<PageHiddenResponse>;
+    remove: (pageId: PageId, node: NavigationNode<NavigationData>) => Promise<PageHiddenResponse>;
+}