@omnia/wcm 8.0.0-vnext → 8.0.1-vnext

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

@@ -0,0 +1,94 @@
+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 } 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>;
+}

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,18 @@
+import { PageId, PublishingRule, VersionId, PublishingRuleData, PageData, ApprovalRequestInfo } from "../models";
+import { RejectPageInfo } from "../models/publishingrule/RejectPageInfo";
+import { ApprovalRuleData } from "../../models";
+export declare class PublishingRuleService {
+    private httpClient;
+    private readonly baseUrl;
+    addRule: (rule: PublishingRuleData, pageVersionId: VersionId) => Promise<PublishingRule>;
+    getPageRules: (pageId: PageId) => Promise<{
+        [versionId: number]: PublishingRule<PublishingRuleData>[];
+    }>;
+    updateRule: (rule: PublishingRule) => Promise<PublishingRule>;
+    cancelApproval: (rule: PublishingRule<ApprovalRuleData>) => Promise<Array<PublishingRule>>;
+    approveApproval: (rule: PublishingRule<ApprovalRuleData>) => Promise<PublishingRule<ApprovalRuleData>>;
+    rejectApproval: (rejectPageInfo: RejectPageInfo) => Promise<Array<PublishingRule>>;
+    deleteRule: (id: number) => Promise<PublishingRule>;
+    getPageVersionRules: (versionId: VersionId) => 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/UrlStateService.d.ts

@@ -0,0 +1,9 @@
+import { UrlStatusModel, UrlStatusMonthlyCountView, UrlStatusMonthlySummaryView, UrlStatusQuery } from "../models";
+export declare class UrlStateService {
+    private httpClient;
+    private readonly baseUrl;
+    getMonthlyCount: (payload: UrlStatusQuery) => Promise<UrlStatusMonthlyCountView[]>;
+    getMonthlyCountByUrls: (payload: UrlStatusQuery) => Promise<UrlStatusMonthlySummaryView[]>;
+    getUrlDetails: (payload: UrlStatusQuery) => Promise<UrlStatusModel[]>;
+    saveUrl: (payload: UrlStatusModel) => Promise<void>;
+}

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,20 @@
+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 "./UrlStateService";

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: {};
+}

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

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

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

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

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

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

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

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

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

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

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

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