@omnia/wcm 8.0.1-dev → 8.0.2-dev

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

@@ -0,0 +1,54 @@
+export declare module PageRollupEnums {
+    enum DatePeriods {
+        OneWeekFromToday = 1,
+        TwoWeeksFromToday = 2,
+        OneMonthFromToday = 3,
+        LaterThanToday = 4,
+        EarlierThanToday = 5
+    }
+    enum FilterTypes {
+        FixedValue = 1,
+        CurrentPage = 2,
+        User = 3,
+        CurrentTerm = 4,
+        CurrentUser = 5,
+        SelectedUser = 6
+    }
+    enum DateTimeModes {
+        Normal = 1,
+        Social = 2
+    }
+    enum BooleanFilterOptions {
+        Yes = 1,
+        No = 2
+    }
+    enum RollupScopes {
+        Tenant = 1,
+        PublishingApps = 2,
+        PageCollections = 3,
+        Subscriptions = 4,
+        NavigationPath = 5,
+        Channels = 6,
+        BusinessProfiles = 7
+    }
+    enum QueryConfigurationType {
+        QueryBuilder = 0,
+        PickPages = 1
+    }
+    enum NodeType {
+        CurrentNode = 0,
+        Custom = 1
+    }
+    enum WorkflowStatus {
+        Default = 0,
+        CheckedOut = 1,
+        WaitingForApproval = 2,
+        ScheduleForPublishing = 4,
+        UnpublishedChanges = 8
+    }
+    enum VersionStatus {
+        Any = 0,
+        Drafts = 1,
+        Published = 2
+    }
+}

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

@@ -0,0 +1,31 @@
+import { PropertyIndexedType, GuidValue, MultilingualString } from "@omnia/fx/models";
+import { PageRollupEnums, PageRollupViewSettings } from "..";
+export interface ListViewColumn {
+    internalName: string;
+    type: PropertyIndexedType;
+    width?: string;
+    isShowHeading?: boolean;
+    showCustomLabel?: boolean;
+    customLabel?: MultilingualString;
+}
+export interface ListViewDateTimeColumn extends ListViewColumn {
+    type: PropertyIndexedType.DateTime;
+    mode: PageRollupEnums.DateTimeModes;
+    format: string;
+}
+export interface ListViewMediaColumn extends ListViewColumn {
+    type: PropertyIndexedType.Media;
+    imagePropRatioUniqueId?: GuidValue;
+}
+export interface ListViewUniqueUsersDetailsColumn extends ListViewColumn {
+    targetNoOfUsers?: number;
+    showDetails?: boolean;
+}
+export interface ListViewPersonColumn extends ListViewColumn {
+    showAvatar?: boolean;
+    showUserName?: boolean;
+}
+export interface PageRollupListViewSettings extends PageRollupViewSettings {
+    columns: Array<ListViewColumn>;
+    fixedHeader?: boolean;
+}

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

@@ -0,0 +1,10 @@
+import { PageRollupViewSettings } from "..";
+import { GuidValue } from "@omnia/fx-models";
+export interface PageRollupListingWithImageViewSettings extends PageRollupViewSettings {
+    imageProp: string;
+    dateProp: string;
+    summaryProp: string;
+    showLikesComments: boolean;
+    showRating: boolean;
+    imagePropRatioUniqueId?: GuidValue;
+}

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

@@ -0,0 +1,67 @@
+import { PageQuery, PageDetailQueryResult, PageId, PageNavigationNode, PageNavigationData, QueryFilter } from "..";
+import { PageRollupEnums } from "./PageRollupEnums";
+export interface PageRollupQuery {
+    uniqueKey: string;
+    itemQuery: PageQuery;
+}
+export interface PriorityPageRollupQuery extends PageRollupQuery {
+    selectProperties: Array<string>;
+    priority: number;
+    disableDistinct: boolean;
+    htmlElement: HTMLElement;
+}
+export interface NormalPageRollupQuery extends PageRollupQuery {
+    selectProperties: Array<string>;
+}
+export interface NormalPageRollupPagingQuery {
+    uniqueKey: string;
+    pageNumber: number;
+    concatPagingResult: boolean;
+    sortBy?: string;
+    sortDesc?: boolean;
+}
+export interface BatchQueryPages extends PageQuery {
+    pageStatisticsPeriod: PageRollupEnums.DatePeriods;
+    queryId: string;
+    internalNames?: Array<string>;
+    trimDuplicates?: boolean;
+    excludeVariations?: boolean;
+    priority?: number;
+    contentLimit?: number;
+    contentProp?: string;
+    queryItemLimit?: number;
+    enableClientCaching?: boolean;
+    versionStatus?: PageRollupEnums.VersionStatus;
+}
+export interface UIQueryFilter {
+    queryFilters: QueryFilter[];
+    pageNumber: number;
+}
+export interface ExportQueryPagesRequest extends BatchQueryPages {
+    displayColumns: {
+        [internalName: string]: string;
+    };
+}
+export interface ExportQueryPagesResult {
+    fileToken: string;
+    queueMessageId: string;
+}
+export interface BatchedPagesResult {
+    total: number;
+    pageIds: PageId[];
+    errorMessage: string;
+    hasError: boolean;
+}
+export interface BatchQueryPagesResult {
+    pagesDetail: PageDetailQueryResult[];
+    batchQueryResult: {
+        [queryId: string]: BatchedPagesResult;
+    };
+}
+export interface ExtendedInformationPageQueryData {
+    pageNavigationNodes: Array<PageNavigationNode<PageNavigationData>>;
+    visitedPageIds: Array<PageId>;
+}
+export interface BatchQueryPagesError extends BatchQueryPages {
+    error: string;
+}

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

@@ -0,0 +1,11 @@
+import { GuidValue } from "@omnia/fx/models";
+import { PageRollupEnums } from ".";
+export interface PageRollupRegistrationView {
+    title: string;
+    componentManifestId: GuidValue;
+    settingsComponentManifestId?: GuidValue;
+    id?: GuidValue;
+    supportClassicPaging?: boolean;
+    supportScrollPaging?: boolean;
+    limitRollupScopes?: Array<PageRollupEnums.RollupScopes>;
+}

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

@@ -0,0 +1,11 @@
+import { PageRollupViewSettings } from "..";
+import { GuidValue } from "@omnia/fx-models";
+export interface PageRollupRollerViewSettings extends PageRollupViewSettings {
+    overlay: number;
+    imageProp: string;
+    dateProp: string;
+    showLikesComments: boolean;
+    imagePropRatioUniqueId?: GuidValue;
+    overlayOpacity: number;
+    overlayColor: string;
+}

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

@@ -0,0 +1,7 @@
+export interface ResolveReusablePageResult {
+    pageId: number;
+    reusable: boolean;
+    enterpriseProperties: {
+        [key: string]: any;
+    };
+}

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

@@ -0,0 +1,4 @@
+export interface UrlResolvedResult {
+    appUrl: string;
+    pageUrl: string;
+}

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

@@ -0,0 +1,19 @@
+export * from "./PageRollupRegistrationView";
+export * from "./PageCollectionSelection";
+export * from "./PageRollupListingWithImageViewSettings";
+export * from "./PageRollupRollerViewSettings";
+export * from "./PageRollupListViewSettings";
+export * from "./PageDetailsQuery";
+export * from "./PageImage";
+export * from "./IPageRollupViewInterface";
+export * from "./PageRollupQuery";
+export * from "./PageRollupEnums";
+export * from "./ResolveReusablePageResult";
+export * from "./UrlResolvedResult";
+export * from "./DynamicRollerViewSettings";
+export * from "./DynamicRollerViewEnums";
+export * from "./CardViewEnums";
+export * from "./CardViewSettings";
+export * from "./NewsletterViewSettings";
+export * from "./NavigationViewSettings";
+export * from "./PageRollupCalendarViewSettings";

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

@@ -0,0 +1,14 @@
+import { VersionedPageData } from "./VersionedPageData";
+import { PageData } from "./PageData";
+import { PageId } from "./Page";
+import { GuidValue, Identity } from "@omnia/fx-models";
+export interface ApprovalRequestInfo<T extends PageData> {
+    approver: Identity;
+    requestMessage: string;
+    versionToSend: VersionedPageData<T>;
+    pageCollectionId: number;
+    isCommunityApp: boolean;
+    pageId: PageId;
+    pageVersionId: number;
+    stepId: GuidValue;
+}

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

@@ -0,0 +1,11 @@
+import { PageId } from "./Page";
+export declare enum ValidationArchivePageResult {
+    NotAllowed = 0,
+    Allowed = 1,
+    AdditionalActionRequired = 2
+}
+export interface ArchivePageResult {
+    versionId: number;
+    softDeletedPageIds: Array<PageId>;
+    softDeletedAt: string;
+}

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

@@ -0,0 +1,20 @@
+import { PageId } from "./Page";
+import { PageNavigationNode, PageNavigationData } from "..";
+import { GuidValue } from "@omnia/fx-models";
+export interface AutomaticCreatedPage {
+    id: GuidValue;
+    sourcePageId: PageId;
+    targetPageCollectionId: PageId;
+    targetPageId?: PageId;
+    status: AutomaticCreatedPageStatus;
+}
+export interface TargetAutomaticCreatedPageData extends AutomaticCreatedPage {
+    targetNavigationNode?: PageNavigationNode<PageNavigationData>;
+    targetPageUrl?: string;
+    targetPageTitle?: string;
+}
+export declare enum AutomaticCreatedPageStatus {
+    Pending = 1,
+    Success = 2,
+    Failed = 3
+}

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

@@ -0,0 +1,9 @@
+import { VersionedPageData } from "./VersionedPageData";
+import { PageData } from "./PageData";
+import { Identity } from "@omnia/fx-models";
+export interface CheckedOutVersionPageData<T extends PageData> extends VersionedPageData<T> {
+    /**
+     * The user login name of the user how has the version checked out
+     * */
+    checkedOutBy: Identity;
+}

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

@@ -0,0 +1,11 @@
+import { CheckedOutVersionPageData } from "./CheckedOutVersionPageData";
+import { PageNavigationNode, PageNavigationData } from "../navigation";
+import { PageData } from "./PageData";
+import { Page } from "./Page";
+export interface CreatedPageInfo<T extends PageData> {
+    checkedOutVersion: CheckedOutVersionPageData<T>;
+    page: Page;
+}
+export interface CreatedPageWithNavigationInfo<T extends PageData> extends CreatedPageInfo<T> {
+    pageNavigationNode: PageNavigationNode<PageNavigationData>;
+}

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

@@ -0,0 +1,5 @@
+export declare enum CurrentPageStatus {
+    UnAuthorize = 401,
+    Ok = 200,
+    Error = 500
+}

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

@@ -0,0 +1,6 @@
+import { VariationPage } from "./VariationPage";
+export interface DefaultVariationPage extends VariationPage {
+    variationPages: {
+        [variationId: number]: VariationPage;
+    };
+}

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

@@ -0,0 +1,4 @@
+export interface EnterprisePropertiesInheritance {
+    enterpriseProperties: Array<string>;
+    pageId: number;
+}

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

@@ -0,0 +1,20 @@
+import { NavigationNode, NavigationData } from "../navigation";
+import { Guid } from "@omnia/fx-models";
+import { PageId } from "./Page";
+export interface MovePagesResult {
+    /**
+     * Information about the new position and the old position
+     * Contains all nodes affected by the move, these nodes contains the updated state after the move
+     * Nodes affected by new position and old position, also contains the moved node
+     * **/
+    affectedNodes: Array<NavigationNode<NavigationData>>;
+    /**
+     * The node that has been moved
+     *
+     * **/
+    movedNode: NavigationNode<NavigationData>;
+    securityResourceId: Guid;
+    pageIdsWithNewSecurityResourceId: PageId[];
+    hiddenByPageId?: PageId;
+    pageIdsWithNewHiddenByPageId: PageId[];
+}

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

@@ -0,0 +1,9 @@
+export interface ImagePropertyOpenAIMapping {
+    url: string;
+    fileName: string;
+}
+export interface OpenAIPropertyMappingValue {
+    summary: string;
+    text: string;
+    image: ImagePropertyOpenAIMapping;
+}

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

@@ -0,0 +1,25 @@
+import { VersionReference } from "./VersionReference";
+import { WCMPageTypes } from ".";
+import { GuidValue, Identity } from "@omnia/fx-models";
+import { AuditingInformation } from "../auditinginformation/AuditingInformation";
+/**
+ * This is no enum, it's the unique id of the page and generated serverside.
+ * */
+export declare enum PageId {
+}
+export interface PageIdToPageMap {
+    [pageId: number]: Page;
+}
+export interface Page extends AuditingInformation {
+    id: PageId;
+    pageType: number | WCMPageTypes;
+    publishingAppId: string;
+    hiddenByPageId?: PageId;
+    checkedOutBy: Identity;
+    checkedOutDraftVersion?: VersionReference;
+    publishedBy: Identity;
+    latestPublishedVersion?: VersionReference;
+    latestDraftVersion: VersionReference;
+    securityResourceId: GuidValue;
+    pageCollectionId?: PageId;
+}

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

@@ -0,0 +1,116 @@
+import { EnterprisePropertyDefinition, GuidValue, IVersionedDataIdentifier, MultilingualString, TimePeriodSettings } from "@omnia/fx-models";
+import { PageId } from ".";
+import { ChildStructureType } from "..";
+import { QueryFilter } from "../query";
+import { PagePermissionInfo } from "./PagePermissionInfo";
+import { PlainPageData } from "./PlainPageData";
+export interface PageCreationSettings {
+    creationDialogTitle: MultilingualString;
+    showUrl: boolean;
+    showProperties: boolean;
+    autoPublish: boolean;
+}
+export interface ActivityPointSettings {
+    enableActivityPoints: boolean;
+    pointsPerActivity: {
+        [id: number]: number;
+    };
+}
+export interface OpenAIPropertiesMapping {
+    imgProp: string;
+    summaryProp: string;
+    textProp: string;
+}
+export interface PageCollectionData extends PlainPageData {
+    availablePageTypes: Array<PageId>;
+    pageCreationSettings: PageCreationSettings;
+    activityPointSettings: ActivityPointSettings;
+    enableNotificationReset: boolean;
+    enableActivityTracking: boolean;
+    enableSendPageEmail: boolean;
+    automaticPageCreationRules: Array<AutomaticPageCreationRule>;
+    schedulingSettings: SchedulingSettings;
+    breakPermissionInheritance: boolean;
+    allowInvitationOfCoAuthors: boolean;
+    enableAutoSubscription?: boolean;
+    enablePublishingToChannel: boolean;
+    yammerIntegrationRules: Array<YammerIntegrationRule>;
+    overriddenPageTypeSettings?: OverriddenPageTypeSetting[];
+    taxonomyPropertyConnectionSettings: TaxonomyPropertyConnectionSettings;
+    enableMandatoryChannels: boolean;
+    enableOpenAISetting: boolean;
+    openAIPropertiesMapping?: OpenAIPropertiesMapping;
+    imgPropOpenAIRatioUniqueId?: GuidValue;
+    /**
+     * This property is used as inital value for creating Page Collection Navigation Node.
+     * */
+    childStructureType?: ChildStructureType;
+}
+export interface AutomaticPageCreationRule {
+    id: GuidValue;
+    connectedTenantId: GuidValue;
+    name: string;
+    targetParentPageId: PageId;
+    targetPageTypeId: PageId;
+    matchCriterias: Array<QueryFilter>;
+    reuseContentSettings: ReuseContentSettings;
+    variationMappings: Array<VariationMapping>;
+    autoPublish: boolean;
+}
+export interface ReuseContentSettings {
+    propertyInternalNames: Array<string>;
+    enterprisePropertyInternalNameMapping: Array<EnterprisePropertyInternalNameMapping>;
+    mode: ReuseContentMode;
+}
+export declare enum ReuseContentMode {
+    enableReuseContent = 0,
+    copyOnCreation = 1
+}
+export interface VariationMapping {
+    sourceVariationId?: number;
+    targetVariationId?: number;
+}
+export interface EnterprisePropertyInternalNameMapping {
+    sourcePropertyInternalName: string;
+    targetPropertyInternalName: string;
+}
+export interface SchedulingSettings {
+    enableScheduling: boolean;
+    schedulingEnterprisePropertyName: string;
+}
+export interface TaxonomyPropertyConnectionSettings {
+    enableTaxonomyConnection: boolean;
+    taxonomyConnectionEnterprisePropertyName: string;
+}
+export interface PageCollectionLayoutRefData extends PageCollectionData {
+    layoutVersionedDataIdentifier: IVersionedDataIdentifier;
+}
+export interface PageCollectionPermissionData extends PageCollectionData {
+    permissions?: PagePermissionInfo;
+}
+export interface CreatePageCollectionLayoutRefData extends PageCollectionLayoutRefData {
+    urlSegment: string;
+    childStructureType: ChildStructureType;
+}
+export interface YammerIntegrationRule {
+    id: GuidValue;
+    yammerGroupId: number;
+    matchCriterias: Array<QueryFilter>;
+    propertiesMapping: Record<YammerProperties, EnterprisePropertyDefinition>;
+}
+export declare enum YammerProperties {
+    Title = "Title",
+    Summary = "Summary",
+    Content = "Content"
+}
+export interface OverriddenPageTypeSetting {
+    pageTypeId: number;
+    overriddenProperties: Array<OverriddenProperty>;
+}
+export interface OverriddenProperty {
+    propertyId?: GuidValue;
+    defaultValue?: any;
+    calculatedFromProperty?: string;
+    timePeriodSettingsForDefaultValue?: TimePeriodSettings;
+    readonly?: boolean;
+}

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

@@ -0,0 +1,25 @@
+import { MultilingualString } from "@omnia/fx-models";
+import { ChildStructureType, PageData, VariationId } from "@omnia/wcm/models";
+import { NavigationNode, NavigationData, NavigationPosition } from "../navigation";
+import { PageId } from "./Page";
+export interface PageCreationInfo {
+    title: string | MultilingualString;
+    urlSegment?: string;
+    parentNavigationNode?: NavigationNode<NavigationData>;
+    parentLayoutPageId?: PageId;
+    type: number;
+    tenantScope?: boolean;
+    childStructureType?: ChildStructureType;
+}
+export interface PageCreationRequest {
+    pageData: PageData;
+    tenantScope?: boolean;
+}
+export interface PageWithNavigationCreationRequest extends PageCreationRequest {
+    urlSegment: string;
+    position: NavigationPosition;
+}
+export interface VariationPageCreationRequest extends PageCreationRequest {
+    originalPageId: PageId;
+    variationId: VariationId;
+}

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

@@ -0,0 +1,41 @@
+import { GuidValue, IVersionedDataIdentifier, Layout, MultilingualString, SearchValue } from "@omnia/fx-models";
+import { EnterprisePropertiesInheritance, ApprovalData } from ".";
+import { PageId } from "./Page";
+/**
+ * This is no enum, it's only used to get typying and compile errors.
+ * */
+export declare enum PageDataType {
+}
+/**
+ * Used for filtering etc
+ * */
+export declare class WCMPageTypes {
+    static plainPage: PageDataType;
+    static pageType: PageDataType;
+    static pageCollection: PageDataType;
+    static all: number;
+}
+export interface PageData {
+    /**
+     * Uses const values and not enum so new types might be defined by others
+     * Use type value > 4096 for none wcm types
+     * For wcm any of WCMPageTypes
+     * */
+    type: PageDataType;
+    pageRendererId: GuidValue;
+    title: string | MultilingualString;
+    layout: Layout;
+    parentLayoutPageId?: PageId;
+    enterpriseProperties?: {
+        [key: string]: any;
+    };
+    enterprisePropertiesInheritance?: EnterprisePropertiesInheritance;
+    layoutVersionedDataIdentifier?: IVersionedDataIdentifier;
+    approvalData?: ApprovalData;
+    propertyBag?: {
+        search: {
+            [blockId: string]: SearchValue;
+        };
+        [key: string]: any;
+    };
+}

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

@@ -0,0 +1,18 @@
+import { PageImage } from "../pagequery";
+export interface PageDialogData {
+    title: string;
+    summary: string;
+    content: string;
+    image: PageImage;
+    showLikeComment: boolean;
+    like: number;
+    comment: number;
+    date?: string;
+}
+export interface PageDialogPropertiesMapping {
+    contentImgProp: string;
+    summaryProp: string;
+    contentProp: string;
+    contactProp: string;
+    dateProp: string;
+}

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

@@ -0,0 +1,9 @@
+import { FileMetadata, GuidValue } from "@omnia/fx-models";
+import { VersionId } from "./VersionedPageData";
+export declare class PageFile implements FileMetadata {
+    omniaServiceId: GuidValue;
+    metadataTypeId: GuidValue;
+    fileName: string;
+    versionId: VersionId;
+    constructor(fileName: string, versionId: VersionId);
+}

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

@@ -0,0 +1,5 @@
+import { PageId } from "./Page";
+export interface PageHiddenResponse {
+    hiddenBy: PageId;
+    pageIds: PageId[];
+}

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

@@ -0,0 +1,12 @@
+import { PageId } from "./Page";
+import { Guid, Identity } from "@omnia/fx-models";
+export interface PagePermissionInfo {
+    editors?: Identity[];
+    authors?: Identity[];
+    readers?: Identity[];
+    admins?: Identity[];
+}
+export interface PagePermissionResponse {
+    securityResourceId: Guid;
+    pageIds: PageId[];
+}

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

@@ -0,0 +1,50 @@
+import { EnterprisePropertyDefinition, EnterprisePropertyItemSettings, GuidValue, Identity, MultilingualString, TimePeriodSettings } from "@omnia/fx-models";
+import { RichTextEditorExtension } from "@omnia/fx/ux/richtexteditor";
+import { SharepointSyncPageSettings } from "internal/fx/internal/models";
+import { PageData } from "./PageData";
+/**
+ * We should update to use nheritance interfaces pattern
+ * This model is not good (maybe be bad in the future if continues adding more properties) because :
+ *      -ReceiveEmail                                     - only used for person property.
+ *      -AllowMultipleValues                              - only used for person/taxonomy property.
+ *      -IncludeTime,timePeriodSettingsForDefaultValue    - only used for datetime property.
+ *
+ * but this need a data migration to fix!
+ * */
+export interface PageTypePropertyInfo extends EnterprisePropertyItemSettings {
+    showInNewPage: boolean;
+    showInEditProperties: boolean;
+    defaultValue?: any;
+    calculatedFromProperty: string;
+    timePeriodSettingsForDefaultValue?: TimePeriodSettings;
+    readonly?: boolean;
+    category: string;
+    receiveEmail?: boolean;
+    allowMultipleValues?: boolean;
+    limitUsersOrGroups?: Array<Identity>;
+    includeTime?: boolean;
+    providerId?: GuidValue;
+    multiLine?: boolean;
+    useFileNameAsPageTitle?: boolean;
+    enableSubscription?: boolean;
+    maxLength?: number;
+    onConfigureExtensions?: (extensions: Array<RichTextEditorExtension>) => RichTextEditorExtension[];
+}
+export interface PageTypeData extends PageData {
+    title: MultilingualString;
+    availableContentProperties: {
+        [internalName: string]: PageTypePropertyInfo;
+    };
+    propertiesSortOrder: string[];
+    sharepointSyncPageSettings?: SharepointSyncPageSettings;
+    automaticArchiveSettings: AutomaticArchiveSettings;
+}
+export interface PageTypeProperty extends EnterprisePropertyDefinition {
+    info: PageTypePropertyInfo;
+}
+export interface ContentPropertyWithInfo extends EnterprisePropertyDefinition {
+    info?: PageTypePropertyInfo;
+}
+export interface AutomaticArchiveSettings {
+    property: string;
+}