@omnia/management-system 7.6.23-preview → 7.6.23

package/internal-do-not-import-from-here/apis/documents/DocumentLibraryCommandButtonApi.d.ts

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

package/internal-do-not-import-from-here/apis/documents/DocumentLibraryCommandButtonApi.manifest.d.ts

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

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

@@ -4,6 +4,8 @@ import { ShapeTemplate } from "./models/data/shapetemplates/ShapeTemplate";
 import { Version } from "./models/shared/Version";
 import { ContentBlockSettings, LinksBlockSettings, TitleBlockSettings, TasksBlockSettings, PropertiesBlockSettings, ProcessNavigationBlockSettings, DrawingBlockSettings, ProcessLayoutBlockSettings } from "./models";
 import { ActionHandlerRegistrationId } from "@omnia/fx/models";
+export declare const ODMRecentDocumentTypesLocalStorageKey = "odm_recentdocumenttypes_key";
+export declare const OWA_QUERY_PARAMETER = "?Web=1";
 export declare class ODMFeatureIds {
     static get ControlledDocument(): Guid;
     static get CreateNewDocumentInLibrary(): Guid;
@@ -103,6 +105,57 @@ export declare const ShapeHighlightProperties: {
         strokeDashArray: number[];
     };
 };
+export declare const ODMFieldNameConstants: {
+    readonly ODMDocId: string;
+    readonly ODMDocIdNumber: string;
+    readonly ODMEdition: string;
+    readonly ODMRevision: string;
+    readonly ODMPublished: string;
+    readonly ODMReviewDate: string;
+    readonly ODMEditionComment: string;
+    readonly ODMApprovedBy: string;
+    readonly ODMApproved: string;
+    readonly ODMContentLanguage: string;
+    readonly ODMDocumentType: string;
+    readonly ODMDocumentTypeId: string;
+    readonly ODMIsFirstDraftVersion: string;
+    readonly ODMAppendixForDocumentId: string;
+    readonly ODMDocumentHistory: string;
+    readonly ODMIsPublished: string;
+    readonly ODMIsRecord: string;
+    readonly ODMIsArchived: string;
+    readonly ODMRelatedDocuments: string;
+    readonly ODMSignedDocuments: string;
+    readonly ODMAppendices: string;
+    readonly ODMIsAllowToBeUsedAsTemplate: string;
+    readonly ODMIsAllowSignedCopy: string;
+    readonly ODMProperties: string;
+    readonly ODMTemplateDocumentIdNumber: string;
+    readonly ODMTemplateDocumentEditionNumber: string;
+    readonly Title: string;
+    readonly ODMIsLimitedAccess: string;
+    readonly ODMLimitedUsers: string;
+    readonly ODMIsConvertedPDF: string;
+    readonly ODMIsNotifiedUsers: string;
+    readonly ODMListNotifiedUsers: string;
+    readonly ODMIsRequireReadReceipt: string;
+    readonly ODMTemplateId: string;
+    readonly ODMReviewReminderDate: string;
+    readonly ODMIsPreview: string;
+    readonly ODMRetentionDate: string;
+    readonly ODMPublishedBy: string;
+    readonly ODMTableDocId: string;
+    readonly ODMDeletedAt: string;
+    readonly ODMDeletedBy: string;
+};
+export declare const DocumentLibrariesUrl: {
+    readonly Drafts: string;
+    readonly Published: string;
+    readonly Tasks: string;
+    readonly Unprocessed: string;
+    readonly Archived: string;
+    readonly RecycleBin: string;
+};
 export declare const ProcessDefaultData: {
     readonly canvasDefinition: CanvasDefinition;
 };
@@ -143,3 +196,36 @@ export declare const ImageFolders: {
     readonly legacy: string;
 };
 export declare const WebEmojiIcons: Array<string>;
+export declare const OPMEnterprisePropertyInternalNames: {
+    readonly OPMEdition: string;
+    readonly OPMRevision: string;
+    readonly OPMProcessType: string;
+    readonly OPMProcessIdNumber: string;
+    readonly OPMPublished: string;
+    readonly OPMApprovedBy: string;
+    readonly OPMIsArchived: string;
+    readonly OPMIsPublished: string;
+};
+export declare const OPMProcessProperty: {
+    readonly Id: string;
+};
+export declare module Security {
+    const OPMRoleDefinitions: {
+        readonly Author: string;
+        readonly Reader: string;
+        readonly Approver: string;
+        readonly Reviewer: string;
+    };
+    const OPMResourceEvaluators: {
+        readonly SecurityResourceIdResource: string;
+        readonly OPMProcessIdResource: string;
+    };
+    const Parameters: {
+        readonly OPMProcessId: string;
+        readonly SecurityResourceId: string;
+    };
+    const ODMRoleDefinitions: {
+        readonly AppInstanceAuthor: string;
+        readonly AppInstanceReader: string;
+    };
+}

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

@@ -7,3 +7,4 @@ export * from "./routing";
 export * from "./settingsprovider";
 export * from "./apis";
 export * from "./messaging";
+export * from "./processshape";

package/internal-do-not-import-from-here/manifests/omnia.ms.fx.manifest.json

@@ -1 +1 @@
-{"name":"omniaWebpackJsonp['b3d13ef7-5ff8-4496-a283-81a742080aef']['54a125ba-c2f8-4c4c-b549-ce0c3861026b']","content":{"./node_modules/@omnia/management-system/messaging/InternalOPMTopics.js":{"id":"./node_modules/@omnia/management-system/messaging/internalopmtopics.js","buildMeta":{"exportsType":"namespace"},"expo.js":["InternalOPMTopics"]},"./node_modules/@omnia/management-system/services/index.js":{"id":"./node_modules/@omnia/management-system/services/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ImageService","MoveProcessService","PermissionService","ProcessDocumentRelationshipService","ProcessFeedbackService","ProcessRollupService","ProcessService","ProcessTaskService","ProcessTemplateService","ProcessTypeService","QueryablePropertiesService","SettingsService","ShapeTemplateService","SharePointTaskService","TeamAppPropertyService"]},"./node_modules/@omnia/management-system/models/index.js":{"id":"711e87d2-a76a-42d5-8658-eb2d0f74135a","buildMeta":{"exportsType":"namespace"},"expo.js":["AddShapePanelStyles","ArchiveFactory","CenterConfigurableHeightDialogStyles","CenterScrollableDialogStyles","DateTimeMode","DefaultControlSettings","DisplayProcessButtonType","DocumentApproverId","DocumentAuthorsType","DocumentConversions","DocumentTaskBulkUpdateTrackingStatusEnum","DocumentTemplateCategoryFactory","DocumentTemplateContentFactory","DocumentTemplateContentTypes","DocumentTemplateFactory","DocumentTemplateSettingsFactory","DocumentTemplateSettingsTypes","DocumentTypeFactory","DocumentTypeSettingsTypes","DocumentTypeTermSynchronizationStatusStatuses","DrawingCanvasSettingsStyles","DrawingShapeTypes","DynamicKeySetting","Enums","FreeformPickerStyles","GlobalSettings","GraphApiPlannerTaskProgress","MSService","MediaPickerStyles","NavigationNodeStyles","ODMResourceManifests","ODMWebComponentManifests","OPMEnterprisePropertyInternalNames","OPMProcessProperty","OPMResourceManifests","OPMWebComponentManifests","PagingServerQuery","ProcessApproverId","ProcessButtonType","ProcessDefaultControlSettings","ProcessDesignerStyles","ProcessFieldDisplayStyles","ProcessGlobalSettings","ProcessLayoutProvider","ProcessMediaPickerProviderContext","ProcessNavigationBlockStyles","ProcessPickerStyles","ProcessReviewReminderFactory","ProcessStepDrawingStyles","ProcessStepPickerStyles","ProcessStepStatusType","ProcessStepType","ProcessTaskAssignmentDataType","ProcessTaskProvider","ProcessTemplateFactory","ProcessTemplateLayoutDefinition","ProcessTypeFactory","ProcessTypeSettingsTypes","ProcessTypeTermSynchronizationStatusStatuses","ProcessVersionType","ProcessWorkflowType","ProcessWorkingStatus","PropertySelectionListType","PublishingApprovalSettingsFactory","PublishingApprovalSettingsTypes","RetentionFactory","RetentionTypes","ReviewReminderFactory","ReviewReminderScheduleFactory","ReviewReminderScheduleTypes","ReviewReminderTaskFactory","ReviewReminderTaskSettingsFactory","Security","Setting","ShapeDefinitionFactory","ShapeDefinitionTypes","ShapeGalleryDefaultSettingStyles","ShapeMovingDirection","ShapeSelectionStyles","ShapeSettingsStyles","ShapeTemplateFactory","ShapeTemplateMediaPickerProviderContext","ShapeTemplateType","ShapeTypeStyles","SiteGroupIdSettings","TargetControlIdentifierType","TaskOutcome","TextAlignment","TextPosition","TitleBlockStyles","UnpublishProcessDialogStyles","VDialogScrollableDialogStyles","WorkflowCompletedType"]},"./node_modules/@omnia/management-system/index.js":{"id":"c91869c1-7bd3-46b4-9e71-21d5b16a5460","buildMeta":{"exportsType":"namespace"},"expo.js":["BuiltInActionButtonHandlers","ContentBlockConfigurationFactory","CurrentProcessStore","DefaultDateFormat","DocumentRollupSettingsProvider","DocumentsBlockDataSettingsKey","DrawingBlockConfigurationFactory","FabricShapeDataTypes","ImageFolders","ImageService","InternalOPMTopics","LinksBlockConfigurationFactory","MoveProcessService","ODMDocumentRollupDisplayFields","ODMFeatureIds","OPMFeatureIds","OPMPublicTopics","OPMRouter","OPMSpecialRouteVersion","OPMUtils","OdmPublicTopics","PageRollupSettingsProvider","PagesBlockDataSettingsKey","PermissionService","ProcessDefaultData","ProcessDocumentRelationshipService","ProcessFeedbackService","ProcessLayoutBlockConfigurationFactory","ProcessNavigationConfigurationFactory","ProcessRendererOptions","ProcessRollupConstants","ProcessRollupService","ProcessService","ProcessStore","ProcessTableColumnsConstants","ProcessTaskProviderIds","ProcessTaskService","ProcessTemplateLayoutStore","ProcessTemplateService","ProcessTemplateStore","ProcessTypeService","ProcessTypeStore","PropertiesBlockConfigurationFactory","QueryablePropertiesService","RootProcessStepDesignerItemIds","SettingsService","SettingsStore","ShapeFactory","ShapeHighlightProperties","ShapeTemplateService","ShapeTemplateStore","ShapeTemplatesConstants","SharePointFieldsConstants","SharePointTaskService","SystemProcessProperties","TasksBlockConfigurationFactory","TeamAppPropertyService","TextSpacingWithShape","TitleBlockConfigurationFactory","WebEmojiIcons"]}}}
+{"name":"omniaWebpackJsonp['b3d13ef7-5ff8-4496-a283-81a742080aef']['54a125ba-c2f8-4c4c-b549-ce0c3861026b']","content":{"./node_modules/@omnia/management-system/constants.js":{"id":"./node_modules/@omnia/management-system/constants.js","buildMeta":{"exportsType":"namespace"},"expo.js":["BuiltInActionButtonHandlers","ContentBlockConfigurationFactory","DefaultDateFormat","DocumentLibrariesUrl","DocumentsBlockDataSettingsKey","DrawingBlockConfigurationFactory","ImageFolders","LinksBlockConfigurationFactory","ODMDocumentRollupDisplayFields","ODMFeatureIds","ODMFieldNameConstants","ODMRecentDocumentTypesLocalStorageKey","OPMEnterprisePropertyInternalNames","OPMFeatureIds","OPMProcessProperty","OPMSpecialRouteVersion","OWA_QUERY_PARAMETER","PagesBlockDataSettingsKey","ProcessDefaultData","ProcessLayoutBlockConfigurationFactory","ProcessNavigationConfigurationFactory","ProcessRollupConstants","ProcessTableColumnsConstants","ProcessTaskProviderIds","PropertiesBlockConfigurationFactory","RootProcessStepDesignerItemIds","Security","ShapeHighlightProperties","ShapeTemplatesConstants","SharePointFieldsConstants","SystemProcessProperties","TasksBlockConfigurationFactory","TextSpacingWithShape","TitleBlockConfigurationFactory","WebEmojiIcons"]},"./node_modules/@omnia/management-system/messaging/InternalOPMTopics.js":{"id":"./node_modules/@omnia/management-system/messaging/internalopmtopics.js","buildMeta":{"exportsType":"namespace"},"expo.js":["InternalOPMTopics"]},"./node_modules/@omnia/management-system/processshape/fabricshape/FabricShapeData.js":{"id":"./node_modules/@omnia/management-system/processshape/fabricshape/fabricshapedata.js","buildMeta":{"exportsType":"namespace"},"expo.js":["FabricShapeDataTypes"]},"./node_modules/@omnia/management-system/processshape/fabricshape/index.js":{"id":"./node_modules/@omnia/management-system/processshape/fabricshape/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["FabricShapeDataTypes"]},"./node_modules/@omnia/management-system/processshape/index.js":{"id":"./node_modules/@omnia/management-system/processshape/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["FabricShapeDataTypes","ShapeDefinitionFactory","ShapeFactory"]},"./node_modules/@omnia/management-system/processshape/shapedefinitions/index.js":{"id":"./node_modules/@omnia/management-system/processshape/shapedefinitions/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ShapeDefinitionFactory"]},"./node_modules/@omnia/management-system/processshape/shapedefinitions/ShapeDefinitionData.js":{"id":"./node_modules/@omnia/management-system/processshape/shapedefinitions/shapedefinitiondata.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ShapeDefinitionFactory"]},"./node_modules/@omnia/management-system/processshape/shapes/index.js":{"id":"./node_modules/@omnia/management-system/processshape/shapes/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ShapeFactory"]},"./node_modules/@omnia/management-system/processshape/shapes/Shape.js":{"id":"./node_modules/@omnia/management-system/processshape/shapes/shape.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ShapeFactory"]},"./node_modules/@omnia/management-system/processshape/shapes/ShapeObject.js":{"id":"./node_modules/@omnia/management-system/processshape/shapes/shapeobject.js","buildMeta":{"exportsType":"namespace"},"expo.js":[]},"./node_modules/@omnia/management-system/services/index.js":{"id":"./node_modules/@omnia/management-system/services/index.js","buildMeta":{"exportsType":"namespace"},"expo.js":["ApprovalTaskService","DocumentLibraryService","DocumentService","DocumentTemplateService","DocumentTypeService","ImageService","MoveProcessService","PermissionService","ProcessDocumentRelationshipService","ProcessFeedbackService","ProcessRollupService","ProcessService","ProcessTaskService","ProcessTemplateService","ProcessTypeService","PublishDocumentService","QueryablePropertiesService","ReviewReminderTaskService","ReviewTaskService","SettingsService","ShapeTemplateService","SharePointTaskService","TaskService","TeamAppPropertyService","UserService"]},"./node_modules/@omnia/management-system/models/index.js":{"id":"711e87d2-a76a-42d5-8658-eb2d0f74135a","buildMeta":{"exportsType":"namespace"},"expo.js":["AddShapePanelStyles","ArchiveFactory","CenterConfigurableHeightDialogStyles","CenterScrollableDialogStyles","DateTimeMode","DefaultControlSettings","DisplayProcessButtonType","DocumentApproverId","DocumentAuthorsType","DocumentConversions","DocumentLibraryViewType","DocumentTaskBulkUpdateTrackingStatusEnum","DocumentTemplateCategoryFactory","DocumentTemplateContentFactory","DocumentTemplateContentTypes","DocumentTemplateFactory","DocumentTemplateSettingsFactory","DocumentTemplateSettingsTypes","DocumentTypeFactory","DocumentTypeSettingsTypes","DocumentTypeTermSynchronizationStatusStatuses","DrawingCanvasSettingsStyles","DrawingShapeTypes","DynamicKeySetting","Enums","FreeformPickerStyles","GlobalSettings","GraphApiPlannerTaskProgress","MSService","MediaPickerStyles","NavigationNodeStyles","ODMResourceManifests","ODMWebComponentManifests","OPMResourceManifests","OPMWebComponentManifests","PagingServerQuery","ProcessApproverId","ProcessButtonType","ProcessDefaultControlSettings","ProcessDesignerStyles","ProcessFieldDisplayStyles","ProcessGlobalSettings","ProcessLayoutProvider","ProcessMediaPickerProviderContext","ProcessNavigationBlockStyles","ProcessPickerStyles","ProcessReviewReminderFactory","ProcessStepDrawingStyles","ProcessStepPickerStyles","ProcessStepStatusType","ProcessStepType","ProcessTaskAssignmentDataType","ProcessTaskProvider","ProcessTemplateFactory","ProcessTemplateLayoutDefinition","ProcessTypeFactory","ProcessTypeSettingsTypes","ProcessTypeTermSynchronizationStatusStatuses","ProcessVersionType","ProcessWorkflowType","ProcessWorkingStatus","PropertySelectionListType","PublishingApprovalSettingsFactory","PublishingApprovalSettingsTypes","RetentionFactory","RetentionTypes","ReviewReminderFactory","ReviewReminderScheduleFactory","ReviewReminderScheduleTypes","ReviewReminderTaskFactory","ReviewReminderTaskSettingsFactory","Setting","ShapeDefinitionTypes","ShapeGalleryDefaultSettingStyles","ShapeMovingDirection","ShapeSelectionStyles","ShapeSettingsStyles","ShapeTemplateFactory","ShapeTemplateMediaPickerProviderContext","ShapeTemplateType","ShapeTypeStyles","SiteGroupIdSettings","TargetControlIdentifierType","TaskOutcome","TextAlignment","TextPosition","TitleBlockStyles","UnpublishProcessDialogStyles","VDialogScrollableDialogStyles","WorkflowCompletedType"]},"./node_modules/@omnia/management-system/index.js":{"id":"c91869c1-7bd3-46b4-9e71-21d5b16a5460","buildMeta":{"exportsType":"namespace"},"expo.js":["ApprovalTaskService","BuiltInActionButtonHandlers","ContentBlockConfigurationFactory","CurrentProcessStore","DefaultDateFormat","DocumentConversionStore","DocumentLibrariesUrl","DocumentLibraryService","DocumentPropetiesStore","DocumentRollupSettingsProvider","DocumentService","DocumentSharePointFieldStore","DocumentTemplateService","DocumentTemplateStore","DocumentTypeService","DocumentTypeStore","DocumentsBlockDataSettingsKey","DrawingBlockConfigurationFactory","FabricShapeDataTypes","ImageFolders","ImageService","InternalOPMTopics","LibraryStore","LinksBlockConfigurationFactory","MoveProcessService","NewDocumentStore","ODMDocumentRollupDisplayFields","ODMFeatureIds","ODMFieldNameConstants","ODMRecentDocumentTypesLocalStorageKey","ODMUtils","OPMEnterprisePropertyInternalNames","OPMFeatureIds","OPMProcessProperty","OPMPublicTopics","OPMRouter","OPMSpecialRouteVersion","OPMUtils","OWA_QUERY_PARAMETER","OdmPublicTopics","PageRollupSettingsProvider","PagesBlockDataSettingsKey","PermissionService","ProcessDefaultData","ProcessDocumentRelationshipService","ProcessFeedbackService","ProcessLayoutBlockConfigurationFactory","ProcessNavigationConfigurationFactory","ProcessRendererOptions","ProcessRollupConstants","ProcessRollupService","ProcessService","ProcessStore","ProcessTableColumnsConstants","ProcessTaskProviderIds","ProcessTaskService","ProcessTemplateLayoutStore","ProcessTemplateService","ProcessTemplateStore","ProcessTypeService","ProcessTypeStore","PropertiesBlockConfigurationFactory","PublishDocumentService","QueryablePropertiesService","ReviewReminderTaskService","ReviewTaskService","RootProcessStepDesignerItemIds","Security","SettingsService","SettingsStore","ShapeDefinitionFactory","ShapeFactory","ShapeHighlightProperties","ShapeTemplateService","ShapeTemplateStore","ShapeTemplatesConstants","SharePointFieldsConstants","SharePointTaskService","SystemProcessProperties","TaskService","TasksBlockConfigurationFactory","TeamAppPropertyService","TextSpacingWithShape","TitleBlockConfigurationFactory","UserService","WebEmojiIcons"]}}}

package/internal-do-not-import-from-here/models/components/documentlibrary/DocumentLibraryCommandButtonApi.d.ts

@@ -0,0 +1,38 @@
+import { Future, GuidValue, IExtendApiManifestWithConfiguration, IIcon } from "@omnia/fx/models";
+import { ControlledDocument } from "../../data";
+export declare enum DocumentLibraryViewType {
+    Draft = "4074dea2-4159-422a-8c02-df6f273d3e5f"
+}
+export interface ICommandButtonComponent<T extends ICommandButton = ICommandButton> {
+    button: T;
+}
+export interface ICommandButton {
+    id: GuidValue;
+    title: string;
+    order: number;
+    icon?: IIcon;
+    disabled?: boolean;
+    hidden?: boolean;
+    onInit?: () => Future<void>;
+    onClicked?: (documents: ControlledDocument[]) => Future<void>;
+    componentManifestId?: GuidValue;
+}
+export interface IDraftViewCommandButton extends ICommandButton {
+    onSelectionChanged?: (documents: ControlledDocument[]) => Future<void>;
+}
+export interface IDocumentLibraryCommandButtonApi {
+    addDraftViewButton: (items: IDraftViewCommandButton) => void;
+    getCommandButtonsByType: (viewType: DocumentLibraryViewType) => Future<Array<ICommandButton>>;
+}
+declare module "../../../apis/index" {
+    interface IMSApi {
+        documentLibraryCommandButton: {
+            registration: Promise<IDocumentLibraryCommandButtonApi>;
+        };
+    }
+    interface IMSExtendApiManifest {
+        documentLibraryCommandButton: {
+            registration: IExtendApiManifestWithConfiguration<DocumentLibraryViewType>;
+        };
+    }
+}

package/internal-do-not-import-from-here/models/components/documentlibrary/DocumentLibraryCommandButtonApi.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentLibraryViewType = void 0;
+var DocumentLibraryViewType;
+(function (DocumentLibraryViewType) {
+    DocumentLibraryViewType["Draft"] = "4074dea2-4159-422a-8c02-df6f273d3e5f";
+})(DocumentLibraryViewType = exports.DocumentLibraryViewType || (exports.DocumentLibraryViewType = {}));

package/internal-do-not-import-from-here/models/components/documentlibrary/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./DocumentLibraryDisplaySettings";
 export * from "./DocumentLibrarySettings";
 export * from "./DocumentLibraryViewSettings";
+export * from "./DocumentLibraryCommandButtonApi";

package/internal-do-not-import-from-here/models/components/documentlibrary/index.js

@@ -4,3 +4,4 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./DocumentLibraryDisplaySettings"), exports);
 tslib_1.__exportStar(require("./DocumentLibrarySettings"), exports);
 tslib_1.__exportStar(require("./DocumentLibraryViewSettings"), exports);
+tslib_1.__exportStar(require("./DocumentLibraryCommandButtonApi"), exports);

package/internal-do-not-import-from-here/models/data/settings/DefaultControlSettings.d.ts

@@ -6,6 +6,7 @@ export interface MSTeamsAppTabTargetControlIdentifier extends TargetControlIdent
     channelId: string;
     threadId: string;
     tabId: string;
+    tabEntityId?: string;
     appId: GuidValue;
 }
 export interface AppLayoutTargetControlIdentifier extends TargetControlIdentifier {

package/internal-do-not-import-from-here/models/data/shapedefinitions/ShapeDefinition.d.ts

@@ -1,5 +1,4 @@
 import { MultilingualString, GuidValue } from "@omnia/fx-models";
-import { OmniaTheming } from "@omnia/fx/ux";
 import { FabricShapeData } from "../../../processshape";
 export declare enum ShapeDefinitionTypes {
     Heading = 1,
@@ -19,10 +18,3 @@ export interface ShapeDefinition {
     multilingualTitle?: string;
     clonedNodes?: FabricShapeData[];
 }
-/**
- * NOTE: whenever an new property is added in settings, we need to define its initial value in factory
- * To ensure it fully react on view
- * */
-export declare const ShapeDefinitionFactory: {
-    createDefaultProcessTemplate(theming: OmniaTheming, type?: ShapeDefinitionTypes): ShapeDefinition;
-};

package/internal-do-not-import-from-here/models/data/shapedefinitions/ShapeDefinition.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShapeDefinitionFactory = exports.ShapeMovingDirection = exports.ShapeDefinitionTypes = void 0;
-const fx_models_1 = require("@omnia/fx-models");
-const constants_1 = require("../../../constants");
-const enums_1 = require("../enums");
+exports.ShapeMovingDirection = exports.ShapeDefinitionTypes = void 0;
 var ShapeDefinitionTypes;
 (function (ShapeDefinitionTypes) {
     ShapeDefinitionTypes[ShapeDefinitionTypes["Heading"] = 1] = "Heading";
@@ -17,31 +14,3 @@ var ShapeMovingDirection;
     ShapeMovingDirection[ShapeMovingDirection["Left"] = 2] = "Left";
     ShapeMovingDirection[ShapeMovingDirection["Right"] = 3] = "Right";
 })(ShapeMovingDirection = exports.ShapeMovingDirection || (exports.ShapeMovingDirection = {}));
-/**
- * NOTE: whenever an new property is added in settings, we need to define its initial value in factory
- * To ensure it fully react on view
- * */
-exports.ShapeDefinitionFactory = {
-    createDefaultProcessTemplate(theming, type) {
-        const shapeDefinition = {
-            type: type ? type : ShapeDefinitionTypes.Drawing,
-            title: { isMultilingualString: true },
-            id: fx_models_1.Guid.newGuid()
-        };
-        if (shapeDefinition.type == ShapeDefinitionTypes.Drawing) {
-            shapeDefinition.shapeTemplateId = constants_1.ShapeTemplatesConstants.Diamond.id;
-            shapeDefinition.shapeTemplateType = constants_1.ShapeTemplatesConstants.Diamond.settings.type;
-            shapeDefinition.title = constants_1.ShapeTemplatesConstants.Diamond.title;
-            shapeDefinition.fontSize = 20;
-            shapeDefinition.backgroundColor = theming.promoted.header.background.base;
-            shapeDefinition.textColor = theming.promoted.header.text.base;
-            shapeDefinition.width = 100;
-            shapeDefinition.height = 100;
-            shapeDefinition.textPosition = enums_1.TextPosition.On;
-            shapeDefinition.textAlignment = enums_1.TextAlignment.Center;
-            shapeDefinition.textHorizontalAdjustment = 0;
-            shapeDefinition.textVerticalAdjustment = 0;
-        }
-        return shapeDefinition;
-    }
-};

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

@@ -9,10 +9,10 @@ export * from "./components";
 export * from "./styles";
 export * from "./shared";
 export * from "./contexts";
-export * from "./Constants";
 export * from "./paging";
 export * from "./richtexteditorextensions";
 export * from "./mediapicker";
 export * from "./graph";
 export * from "./processtaskassignments";
 export * from "./processstepstatuses";
+export * from "./readreceiptsignoff";

package/internal-do-not-import-from-here/models/index.js

@@ -13,10 +13,10 @@ tslib_1.__exportStar(require("./components"), exports);
 tslib_1.__exportStar(require("./styles"), exports);
 tslib_1.__exportStar(require("./shared"), exports);
 tslib_1.__exportStar(require("./contexts"), exports);
-tslib_1.__exportStar(require("./Constants"), exports);
 tslib_1.__exportStar(require("./paging"), exports);
 tslib_1.__exportStar(require("./richtexteditorextensions"), exports);
 tslib_1.__exportStar(require("./mediapicker"), exports);
 tslib_1.__exportStar(require("./graph"), exports);
 tslib_1.__exportStar(require("./processtaskassignments"), exports);
 tslib_1.__exportStar(require("./processstepstatuses"), exports);
+tslib_1.__exportStar(require("./readreceiptsignoff"), exports);

package/internal-do-not-import-from-here/models/readreceiptsignoff/DocumentNotifiedPerson.d.ts

@@ -0,0 +1,16 @@
+import { GuidValue, Identity } from "@omnia/fx-models";
+import { ControlledDocument } from "..";
+export interface DocumentNotifiedPerson {
+    id: GuidValue;
+    documentId: GuidValue;
+    identity: Identity;
+    isReadReceiptRequired: boolean;
+    oDMDocId: string;
+    edition: number;
+    isReadAndUnderstood: boolean;
+    publishedDocument: ControlledDocument;
+}
+export interface DocumentNotifiedPersonUI extends DocumentNotifiedPerson {
+    displayName: string;
+    userEmail: string;
+}

package/internal-do-not-import-from-here/models/readreceiptsignoff/DocumentNotifiedPerson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/internal-do-not-import-from-here/models/readreceiptsignoff/DocumentReadReceiptHistory.d.ts

@@ -0,0 +1,9 @@
+import { DocumentNotifiedPerson } from "./DocumentNotifiedPerson";
+export interface DocumentReadReceiptsHistory {
+    edition: number;
+    published: Date;
+    isRequireReadReceipt: boolean;
+    notifiedUsers: Array<DocumentNotifiedPerson>;
+    numberOfSignedOffUsers: number;
+    title?: string;
+}

package/internal-do-not-import-from-here/models/readreceiptsignoff/DocumentReadReceiptHistory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+export * from "./DocumentNotifiedPerson";
+export * from "./DocumentReadReceiptHistory";

package/internal-do-not-import-from-here/models/readreceiptsignoff/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DocumentNotifiedPerson"), exports);
+tslib_1.__exportStar(require("./DocumentReadReceiptHistory"), exports);

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

@@ -1,2 +1,3 @@
 export * from "./shapes";
 export * from "./fabricshape";
+export * from "./shapedefinitions";

package/internal-do-not-import-from-here/processshape/shapedefinitions/ShapeDefinitionData.d.ts

@@ -0,0 +1,9 @@
+import { OmniaTheming } from "@omnia/fx/ux";
+import { ShapeDefinition, ShapeDefinitionTypes } from "../../models";
+/**
+ * NOTE: whenever an new property is added in settings, we need to define its initial value in factory
+ * To ensure it fully react on view
+ * */
+export declare const ShapeDefinitionFactory: {
+    createDefaultProcessTemplate(theming: OmniaTheming, type?: ShapeDefinitionTypes): ShapeDefinition;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { Identity } from "@omnia/fx/models";
+export declare class UserService {
+    private httpClient;
+    constructor();
+    resolveIdentitiesBySPLookupIds: (webUrl: string, spLookupIds: Array<number>) => Promise<Identity[]>;
+}

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

@@ -0,0 +1,56 @@
+import { GuidValue } from "@omnia/fx/models";
+import { CreateDraftFromPublishedRequest, GetDocumentFieldsRequest, GetDraftDocumentAppendicesRequest, GetDocumentFieldsResponse, SharePointField, AppendixWithSharePointFields, ControlledDocument, SqlDocument, Enums, DocumentRequest, ProcessDocumentAndMergeTemplateRequest, PagingRequest, GetControlledDocumentsResponse, DocumentMetadataStatus, ProcessExistedDocumentAndMergeTemplateRequest, PublishedDocumentSharepointStatus, DocumentSharepointStatus, SharePointUser, SetNewReviewDateRequest, SetNewChangeCommentRequest } from "../../models";
+export declare class DocumentService {
+    private httpClient;
+    constructor();
+    updateDocumentFields: (siteUrl: string, documentUrl: string, sharePointFields: Array<SharePointField>, isUpdateDocId: boolean, isUpdateDocStatus: boolean, odmDocId?: string, sqlDocumentId?: GuidValue, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<string>;
+    updateDocumentFieldsStatus: (siteUrl: string, sqlId: GuidValue, odmDocId: string, documentTypeId: GuidValue) => Promise<SqlDocument>;
+    unlockFile: (webUrl: string, spDocumentId: number, sqlId: GuidValue) => Promise<boolean>;
+    getFileLockedByUser: (webUrl: string, spDocumentId: number) => Promise<SharePointUser>;
+    getDocumentFields: (request: GetDocumentFieldsRequest) => Promise<GetDocumentFieldsResponse>;
+    getDraftDocumentAppendices: (request: GetDraftDocumentAppendicesRequest) => Promise<AppendixWithSharePointFields[]>;
+    deleteDraftDocuments: (webUrl: string, spDocumentIds: Array<number>, sqlIds?: Array<GuidValue>) => Promise<void>;
+    deleteAppendixDocuments: (webUrl: string, spDocumentIds: Array<number>) => Promise<void>;
+    permanentlyDeleteDocuments: (webUrl: string, documentIds: Array<string>) => Promise<void>;
+    setStatusPermanentlyDeleteDocuments: (webUrl: string, documentIds: Array<string>) => Promise<Array<DocumentMetadataStatus>>;
+    deleteSignedDocuments: (spUrl: string, documentSpId: number, odmDocId: string) => Promise<void>;
+    createDraftDocumentFrompUnprocessedEdition: (request: CreateDraftFromPublishedRequest) => Promise<ControlledDocument>;
+    createDraftAndMergeTemplate: (request: ProcessDocumentAndMergeTemplateRequest) => Promise<void>;
+    mergeDraftWithTemplate: (request: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<void>;
+    previewMergeWithTemplate: (request: ProcessDocumentAndMergeTemplateRequest) => Promise<void>;
+    copyDocumentsToAppendices: (webUrl: string, selectedDocuments: Array<ControlledDocument>, documentId: number, isOverwrite: boolean) => Promise<void>;
+    createDraftDocumentFrompNewUploadedFile: (file: File, fileName: string, odmDocId: string, edition: number, webUrl: string, isRestoring?: boolean) => Promise<void>;
+    getExistingDraftDocument: (odmDocId: string, webUrl: string) => Promise<ControlledDocument>;
+    getLatestPublishedDocument: (documentId: string, webUrl: string) => Promise<SqlDocument>;
+    getDocumentByDocIdNumber: (docIdNumber: number, webUrl: string) => Promise<ControlledDocument>;
+    deletePublishDocument: (odmDocId: string, odmDocIdNumber: number, webUrl: string, documentTypeId: string, comment: string) => Promise<boolean>;
+    getCurrentUserRolesOfListItems(request: DocumentRequest, library: string): Promise<{
+        [key: number]: Enums.DocumentViewEnums.DocumentRoles[];
+    }[]>;
+    getCurrentUserRolesOfList(webUrl: string, library: string): Promise<Enums.DocumentViewEnums.DocumentRoles[]>;
+    canCurrentUserEditLibraryDocument: (webUrl: string, libraryName: string) => Promise<boolean>;
+    getExpireReviewsDocuments: (request: PagingRequest) => Promise<GetControlledDocumentsResponse>;
+    getDocumentsStatus(request: {
+        [key: string]: GuidValue;
+    }, library: string): Promise<DocumentMetadataStatus[]>;
+    getRecycleBinDocumentsStatus(request: {
+        [key: string]: GuidValue;
+    }): Promise<DocumentMetadataStatus[]>;
+    getPublishedDocumentsSharepointStatus(request: {
+        [key: number]: number;
+    }, webUrl: string, library: string, loadAppendix: boolean, loadSignedDocument: boolean): Promise<PublishedDocumentSharepointStatus[]>;
+    getDocumentsSharepointStatus(request: Array<number>, webUrl: string, library: string): Promise<{
+        [key: number]: DocumentSharepointStatus;
+    }>;
+    getDocumentsTitle(request: Array<number>, webUrl: string, library: string): Promise<{
+        [key: number]: string;
+    }>;
+    updateBulkUpdateCache(webUrl: string): Promise<void>;
+    retoreDraftDocuments(documentIds: string[]): Promise<void>;
+    createDocumentComparison: (webUrl: string, odmDocId: string, leftSideEdition: number, rightSideEdition?: number, draftDocumentSpId?: number, comparisonId?: string, leftSideFileSuffix?: string, rightSideFileSuffix?: string) => Promise<string>;
+    getDocumentComparisonInfo: (comparisonId: string) => Promise<any>;
+    getDocumentComparisonViewUrl: (comparisonId: string, wait?: boolean) => Promise<any>;
+    deleteDocumentComparison: (comparisonId: string) => Promise<any>;
+    setNewReviewDate: (request: SetNewReviewDateRequest) => Promise<ControlledDocument>;
+    setNewChangeComment: (request: SetNewChangeCommentRequest) => Promise<void>;
+}

package/internal-do-not-import-from-here/services/document/DocumentTemplateService.d.ts

@@ -0,0 +1,18 @@
+import { DocumentTemplate, DocumentTemplateCategory, UploadedDocumentTemplateContent, DocumentTemplateContent } from "../../models";
+export declare class DocumentTemplateService {
+    private multilingualStore;
+    private httpClient;
+    constructor();
+    getAllDocumentTemplates: () => Promise<DocumentTemplate[]>;
+    addOrUpdateDocumentTemplate: (documentTemplate: DocumentTemplate, files: {
+        [id: string]: File;
+    }) => Promise<DocumentTemplate>;
+    deleteDocumentTemplate: (documentTemplate: DocumentTemplate) => Promise<void>;
+    getAllDocumentTemplateCategories: () => Promise<DocumentTemplateCategory[]>;
+    addOrUpdateDocumentTemplateCategory: (documentTemplateCategory: DocumentTemplateCategory) => Promise<DocumentTemplateCategory>;
+    deleteDocumentTemplateCategory: (documentTemplateCategory: DocumentTemplateCategory) => Promise<void>;
+    private generateDocumentTemplatesMultilingualText;
+    private generateDocumentTemplateCategoriesMultilingualText;
+    getUploadedDocumentDownloadUrl: (content: UploadedDocumentTemplateContent) => string;
+    checkHeaderFooterHasShape: (template: DocumentTemplateContent) => Promise<boolean>;
+}

package/internal-do-not-import-from-here/services/document/DocumentTypeService.d.ts

@@ -0,0 +1,15 @@
+import { GuidValue, Identity } from "@omnia/fx/models";
+import { DocumentType } from "../../models";
+export declare class DocumentTypeService {
+    private httpClient;
+    constructor();
+    refreshServerCache: () => Promise<void>;
+    getByIds: (ids: Array<GuidValue>) => Promise<Array<DocumentType>>;
+    getChildren: (parentId?: GuidValue) => Promise<Array<DocumentType>>;
+    getDocumentTypeTermSetId: () => Promise<GuidValue>;
+    create: (documentType: DocumentType) => Promise<DocumentType>;
+    update: (documentType: DocumentType) => Promise<DocumentType>;
+    remove: (id: GuidValue) => Promise<void>;
+    getUsersInApproverGroup: (docTypeId: GuidValue, webUrl: string) => Promise<Identity[]>;
+    getByDocumentTemplateId: (documentTemplateId: GuidValue) => Promise<Array<DocumentType>>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./DocumentService";
+export * from "./DocumentTemplateService";
+export * from "./DocumentTypeService";

package/internal-do-not-import-from-here/services/documentlibrary/ApprovalTaskService.d.ts

@@ -0,0 +1,12 @@
+import { ApprovalTask, PublishDocumentWithApprovalRequest, Workflow } from "../../models";
+export declare class ApprovalTaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getApprovalTaskById: (itemId: number, webUrl: string) => Promise<ApprovalTask>;
+    completeApprovalTask: (task: ApprovalTask) => Promise<string>;
+    cancelWorkflow: (documentReview: Workflow) => Promise<void>;
+    publishDocumentWithApproval: (request: PublishDocumentWithApprovalRequest) => Promise<void>;
+    processCompletingApprovalTask: (task: ApprovalTask) => Promise<void>;
+    processCancellingApprovalWorkflow: (approval: Workflow) => Promise<void>;
+}

package/internal-do-not-import-from-here/services/documentlibrary/DocumentLibraryService.d.ts

@@ -0,0 +1,21 @@
+import { GuidValue } from "@omnia/fx/models";
+import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite } from "../../models";
+export declare class DocumentLibraryService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    filterDraftDocuments: (request: DocumentRequest, openInClientApp: boolean) => Promise<GetControlledDocumentsResponse>;
+    filterPublishedDocuments: (request: DocumentRequest, openInClientApp: boolean) => Promise<GetControlledDocumentsResponse>;
+    filterDeletedDocuments: (request: DocumentRequest) => Promise<GetControlledDocumentsResponse>;
+    getLibraryWithFields: (webUrl: string, listUrl: string) => Promise<SPList>;
+    getFilteringOptionsPage: (webUrl: string, listId: string, fieldName: string, viewId: string) => Promise<string>;
+    getNextTaxonomyFilteringHierarchy: (siteUrl: string, listId: string, fieldId: string, termId: string) => Promise<string>;
+    getRestOfFilteringHierarchy: (webUrl: string, listId: string, fieldId: string, termId: string) => Promise<string>;
+    getDisplayFieldsInList: (webUrl: string, listUrl: string) => Promise<SharePointField[]>;
+    getTestFile: () => Promise<void>;
+    mergeMetadataToDocument: (mergeRequest: MergeMetadataRequest, fileData: ArrayBuffer) => Promise<void>;
+    testConvertToPDF: () => Promise<void>;
+    getWorkflowHistories: (sqlId: GuidValue) => Promise<WorkflowHistory[]>;
+    isExistingDraftDocument: (webUrl: string, odmDocId: string) => Promise<boolean>;
+    resolveAuthoringSite: (webUrl: string) => Promise<SPSite>;
+}

package/internal-do-not-import-from-here/services/documentlibrary/PublishDocumentService.d.ts

@@ -0,0 +1,15 @@
+import { GuidValue } from "@omnia/fx/models";
+import { DocumentNotifiedPerson, DocumentReadReceiptsHistory, Enums, PublishDocumentWithoutApprovalRequest, MoveDocumentToTargetSiteRequest, PreviewPublishedDocumentRequest } from "../../models";
+export declare class PublishDocumentService {
+    private httpClient;
+    constructor();
+    fixPublishingFailedDocument: (webUrl: string, odmDocumentId: string, sqlId: GuidValue) => Promise<void>;
+    checkPrePublishCondition: (webUrl: string, spDocumentId: number, sqlId: GuidValue, status: Enums.DocumentViewEnums.LibraryDocumentStatus) => Promise<boolean>;
+    publishDocumentWithoutApproval: (request: PublishDocumentWithoutApprovalRequest) => Promise<void>;
+    previewPublishedDocument: (request: PreviewPublishedDocumentRequest) => Promise<void>;
+    getReadReceiptSignOffByOdmDocId: (odmDocId: string, webUrl: string) => Promise<DocumentNotifiedPerson>;
+    getReadReceiptHistory: (odmDocId: string, webUrl: string) => Promise<Array<DocumentReadReceiptsHistory>>;
+    setReadReceiptSignOffStatus: (id: GuidValue, isReadAndUnderstood: boolean) => Promise<void>;
+    setMovingToTargetSiteDocumentStatus: (sqlDocumentId: string, odmDocumentId: string, currentSiteUrl: string, targetSiteUrl: string) => Promise<Enums.DocumentViewEnums.LibraryDocumentStatus>;
+    movePageToTargetSite: (moveDocumentRequest: MoveDocumentToTargetSiteRequest) => Promise<void>;
+}

package/internal-do-not-import-from-here/services/documentlibrary/ReviewReminderTaskService.d.ts

@@ -0,0 +1,5 @@
+import { CompleteReviewReminderTaskRequest } from "../../models";
+export declare class ReviewReminderTaskService {
+    private httpClient;
+    completeReviewReminderTask: (request: CompleteReviewReminderTaskRequest) => Promise<void>;
+}

package/internal-do-not-import-from-here/services/documentlibrary/ReviewTaskService.d.ts

@@ -0,0 +1,17 @@
+import { Workflow, ReviewTaskParams, ReviewTask, SqlDocument, SharePointUser, WorkflowTask } from "../../models";
+export declare class ReviewTaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getReviewTaskById: (itemId: number, webUrl: string) => Promise<ReviewTask>;
+    completeReviewTask: (request: ReviewTaskParams) => Promise<string>;
+    processCompletingReviewTask: (task: ReviewTask) => Promise<void>;
+    getFileLockedByUserWhenTaskIsLastIncompleted: (task: ReviewTask) => Promise<SharePointUser>;
+    sendDocumentToReview: (params: ReviewTaskParams) => Promise<SqlDocument>;
+    processSendingDocumentToReview: (params: ReviewTaskParams) => Promise<void>;
+    addNewReviewer: (params: ReviewTaskParams) => Promise<WorkflowTask[]>;
+    forwardToReviewer: (params: ReviewTaskParams) => Promise<string>;
+    cancelReviewWorkflow: (documentReview: Workflow, spId: number, webUrl: string) => Promise<void>;
+    processCancellingReviewWorkflow: (documentReview: Workflow) => Promise<void>;
+    removeReviewTask: (task: ReviewTask) => Promise<boolean>;
+}

package/internal-do-not-import-from-here/services/documentlibrary/TaskService.d.ts

@@ -0,0 +1,11 @@
+import { GuidValue } from "@omnia/fx/models";
+import { Workflow, DocumentTaskDetail, TaskRequest, TaskItemResponse, Enums } from "../../models";
+export declare class TaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getFilterTasks: (request: TaskRequest) => Promise<TaskItemResponse>;
+    getTaskById: (webUrl: string, taskId: number) => Promise<DocumentTaskDetail>;
+    getDocumentWorkflow: (spDocumentId: number, sqlId: GuidValue, webUrl: string, workflowType?: Enums.DocumentViewEnums.WorkflowType) => Promise<Workflow>;
+    deleteTask: (webUrl: string, spId: number) => Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+export * from "./TaskService";
+export * from "./DocumentLibraryService";
+export * from "./ReviewTaskService";
+export * from "./PublishDocumentService";
+export * from "./ReviewReminderTaskService";
+export * from "./ApprovalTaskService";

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

@@ -13,3 +13,6 @@ export * from "./MoveProcessService";
 export * from "./ProcessFeedbackService";
 export * from "./QueryablePropertiesService";
 export * from "./ProcessTaskService";
+export * from "./documentlibrary";
+export * from "./document";
+export * from "./UserService";

package/internal-do-not-import-from-here/stores/documentlibrary/DocumentConversionStore.d.ts

@@ -0,0 +1,14 @@
+import { Store } from "@omnia/fx/stores";
+export declare class DocumentConversionStore extends Store {
+    private conversionSettingsPromise;
+    private supportCustomProvider;
+    getters: {
+        supportCustomProvider: () => boolean;
+    };
+    mutations: {};
+    actions: {
+        checkSupportCustomProvider: import("@omnia/fx/stores").StoreAction<unknown, (ensureFunc: Promise<boolean>) => void, (result: boolean, ensureFunc: Promise<boolean>) => void, (failureReason: any, ensureFunc: Promise<boolean>) => void, (ensureFunc: Promise<boolean>) => Promise<boolean>>;
+    };
+    onActivated(): void;
+    onDisposing(): void;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/DocumentPropetiesStore.d.ts

@@ -0,0 +1,32 @@
+import { GuidValue } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { SharePointField } from "../../models";
+import { DocumentSharePointFieldStore } from "./DocumentSharePointFieldStore";
+/**
+ * The store is using for process document properties *
+ * */
+export declare class DocumentPropetiesStore extends Store {
+    private enterprisePropertyStore;
+    private enterprisePropertySetStore;
+    private documentTypeStore;
+    documentSharePointFieldStore: DocumentSharePointFieldStore;
+    private teamworkContext;
+    private loadDocumentFieldsPromise;
+    private documentTypeField;
+    private documentTypeIdField;
+    private documentFields;
+    getters: {
+        documentFields: () => SharePointField[];
+        documentTypeFields: () => Array<SharePointField>;
+    };
+    mutations: {};
+    actions: {
+        ensureDocumentTypeFields: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeId: GuidValue, fileUrl: string) => void, (result: void, documentTypeId: GuidValue, fileUrl: string) => void, (failureReason: any, documentTypeId: GuidValue, fileUrl: string) => void, (documentTypeId: GuidValue, fileUrl: string) => Promise<void>>;
+        ensureDocumentFields: import("@omnia/fx/stores").StoreAction<unknown, (...args: string[]) => void, (result: void, ...args: string[]) => void, (failureReason: any, ...args: string[]) => void, (...fileUrls: string[]) => Promise<void>>;
+    };
+    private ensureLoadDocumentFields;
+    private processDocumentFields;
+    private getDocumentFieldsInSet;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/DocumentSharePointFieldStore.d.ts

@@ -0,0 +1,22 @@
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { SharePointField } from "../../models";
+export declare class DocumentSharePointFieldStore extends Store {
+    private documentService;
+    private enterprisePropertyStore;
+    private documents;
+    private SystemColumns;
+    getters: {
+        sharePointFields: (documentUrl: string) => SharePointField[];
+        existNotResolvedPersonFields: (documentUrl: any) => boolean;
+        cannotResolvePersonField: (documentUrl: string, id: GuidValue) => boolean;
+        generateEnterpriseKeywordsFields: (fields: Array<SharePointField>) => Array<SharePointField>;
+        existEnterpriseKeywordsFields: (fields: Array<string>) => boolean;
+    };
+    mutations: {};
+    actions: {
+        ensureDocumentSharePointFields: import("@omnia/fx/stores").StoreAction<unknown, (documentUrl: string, siteUrl: string) => void, (result: any, documentUrl: string, siteUrl: string) => void, (failureReason: any, documentUrl: string, siteUrl: string) => void, (documentUrl: string, siteUrl: string) => Promise<any>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/DocumentTemplateStore.d.ts

@@ -0,0 +1,37 @@
+import { Store } from "@omnia/fx/stores";
+import { DocumentTemplateCategory, DocumentTemplate, DocumentTemplateContent } from "../../models";
+export declare class DocumentTemplateStore extends Store {
+    private documentTemplateSerivice;
+    private documentTemplates;
+    private documentTemplateCategories;
+    private ensureLoadDocumentTemplatesPromise;
+    private ensureLoadDocumentTemplateCategoriesPromise;
+    private checkingMergedTemplatePromises;
+    private templateContentValidChecking;
+    getters: {
+        documentTemplates: () => DocumentTemplate[];
+        documentTemplateCategories: () => DocumentTemplateCategory[];
+        getShapeInFooterHeaderChecking: (template: DocumentTemplateContent) => boolean;
+    };
+    private privateMutations;
+    actions: {
+        ensureLoadDocumentTemplates: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureLoadDocumentTemplateCategories: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        addOrUpdateDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (result: any, documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (failureReason: any, documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => Promise<any>>;
+        addOrUpdateDocumentTemplateCategory: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateCategory: DocumentTemplateCategory) => void, (result: any, documentTemplateCategory: DocumentTemplateCategory) => void, (failureReason: any, documentTemplateCategory: DocumentTemplateCategory) => void, (documentTemplateCategory: DocumentTemplateCategory) => Promise<any>>;
+        deleteDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplate: DocumentTemplate) => void, (result: any, documentTemplate: DocumentTemplate) => void, (failureReason: any, documentTemplate: DocumentTemplate) => void, (documentTemplate: DocumentTemplate) => Promise<any>>;
+        deleteDocumentTemplateCategory: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateCategory: DocumentTemplateCategory) => void, (result: any, documentTemplateCategory: DocumentTemplateCategory) => void, (failureReason: any, documentTemplateCategory: DocumentTemplateCategory) => void, (documentTemplateCategory: DocumentTemplateCategory) => Promise<any>>;
+        ensureCheckingTemplates: import("@omnia/fx/stores").StoreAction<unknown, (template: DocumentTemplateContent) => void, (result: void, template: DocumentTemplateContent) => void, (failureReason: any, template: DocumentTemplateContent) => void, (template: DocumentTemplateContent) => Promise<void>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    private getTemplateKey;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/DocumentTypeStore.d.ts

@@ -0,0 +1,42 @@
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { DocumentType } from "../../models";
+export declare class DocumentTypeStore extends Store {
+    private documentTypeService;
+    private termStore;
+    private multilingualTextsStore;
+    private ensuredChildrenPromises;
+    private ensuredDocumentTypePromises;
+    private refreshCachePromises;
+    private ensureRootDocumentTypePromise;
+    private documentTypeTermSetId;
+    private documentTypes;
+    private documentTypesDict;
+    private documentTypesByDocumentTemplateDict;
+    private loadByDocumentTemplatesPromises;
+    getters: {
+        children: (parentId?: GuidValue, includeInvalid?: boolean) => Array<DocumentType>;
+        byId: (id: GuidValue, includeInvalid?: boolean) => DocumentType;
+        rootDocumentTypeInGlobalSettings: () => DocumentType;
+        SeachTypebyName: (search: string, language: string) => Array<DocumentType>;
+        documentTypesByDocumentTemplate: (documentTemplateId: GuidValue) => Array<DocumentType>;
+    };
+    private isValidDocumentType;
+    private privateMutations;
+    private sortByChildrenOrders;
+    private ensureChildren;
+    actions: {
+        ensureRootDocumentType: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureChildren: import("@omnia/fx/stores").StoreAction<unknown, (parentId?: GuidValue, moving?: boolean) => void, (result: null, parentId?: GuidValue, moving?: boolean) => void, (failureReason: any, parentId?: GuidValue, moving?: boolean) => void, (parentId?: GuidValue, moving?: boolean) => Promise<null>>;
+        createDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: DocumentType, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<DocumentType>>;
+        updateDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: DocumentType, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<DocumentType>>;
+        removeDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: any, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<any>>;
+        ensureDocumentTypes: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeIds: GuidValue[]) => void, (result: any, documentTypeIds: GuidValue[]) => void, (failureReason: any, documentTypeIds: GuidValue[]) => void, (documentTypeIds: Array<GuidValue>) => Promise<any>>;
+        refreshCache: import("@omnia/fx/stores").StoreAction<unknown, (trackingNumber: number) => void, (result: null, trackingNumber: number) => void, (failureReason: any, trackingNumber: number) => void, (trackingNumber: number) => Promise<null>>;
+        ensureDocumentTypeByDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateId: GuidValue) => void, (result: DocumentType[], documentTemplateId: GuidValue) => void, (failureReason: any, documentTemplateId: GuidValue) => void, (documentTemplateId: GuidValue) => Promise<DocumentType[]>>;
+    };
+    private isRootParentId;
+    private getParentId;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/LibraryStore.d.ts

@@ -0,0 +1,85 @@
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { Enums, SharePointField, DocumentMetadataStatus, ProcessExistedDocumentAndMergeTemplateRequest, DocumentSharepointStatus, PublishedDocumentSharepointStatus } from "../../models";
+import { NewDocumentStore } from "./NewDocumentStore";
+import { DocumentPropetiesStore } from "./DocumentPropetiesStore";
+import { DocumentService } from "../../services";
+export declare class LibraryStore extends Store {
+    documentService: DocumentService;
+    private teamworkContext;
+    newDocumentStore: NewDocumentStore;
+    documentPropetiesStore: DocumentPropetiesStore;
+    private isLoadingDraft;
+    private isLoadingPublished;
+    private isLoadingRecycleBin;
+    private listItemsUserRoles;
+    private publishedLibraryUserRoles;
+    private ensureUpdatePropertiesPromises;
+    private publishDocumentPromises;
+    private creatingDraftPromises;
+    private documentStatusPromises;
+    private documentSharepointStatusPromises;
+    private documentsTitlePromises;
+    getters: {
+        isLoadingDraft: () => boolean;
+        isLoadingPublished: () => boolean;
+        isLoadingRecycleBin: () => boolean;
+        listItemsUserRoles: (library: string, id: number) => {
+            [key: string]: Enums.DocumentViewEnums.DocumentRoles[];
+        }[];
+        publishedLibraryUserRoles: () => Array<Enums.DocumentViewEnums.DocumentRoles>;
+        getDocumentStatus: (documents: Array<DocumentMetadataStatus>, siteUrl: string) => Array<DocumentMetadataStatus>;
+        isCreatingDraftStatus: (key: string) => boolean;
+        isPublishingDocument: (sqlId: GuidValue, spWebUrl: string) => boolean;
+    };
+    mutations: {
+        setLoading: import("@omnia/fx/stores").StoreMutation<(isLoading: boolean, lib: string, siteUrl: string) => void, (isLoading: boolean, lib: string, siteUrl: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setListItemsUserRoles: import("@omnia/fx/stores").StoreMutation<(library: string, ids: number[], userRoles: {
+            [id: number]: Enums.DocumentViewEnums.DocumentRoles[];
+        }[]) => void, (library: string, ids: number[], userRoles: {
+            [id: number]: Enums.DocumentViewEnums.DocumentRoles[];
+        }[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setPublishedLibraryUserRoles: import("@omnia/fx/stores").StoreMutation<(userRoles: Array<Enums.DocumentViewEnums.DocumentRoles>) => void, (userRoles: Enums.DocumentViewEnums.DocumentRoles[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        forceReloadDocumentStatus: import("@omnia/fx/stores").StoreMutation<(lib: string, siteUrl: string) => void, (lib: string, siteUrl: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        forceReloadDocument: import("@omnia/fx/stores").StoreMutation<(lib: string, siteUrl: string, sqlId: GuidValue) => void, (lib: string, siteUrl: string, sqlId: GuidValue) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updatePublishPromises: import("@omnia/fx/stores").StoreMutation<(sqlId: GuidValue, siteUrl: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus) => void, (sqlId: GuidValue, siteUrl: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateCreatingDraftPromises: import("@omnia/fx/stores").StoreMutation<(id: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus, msg?: string) => void, (id: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus, msg?: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        clearPublishDocumentPromises: import("@omnia/fx/stores").StoreMutation<() => void, () => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        resetDocumentStatusPromises: import("@omnia/fx/stores").StoreMutation<(url: string, libraryName: string) => void, (url: string, libraryName: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensureUpdateDocumentProperties: import("@omnia/fx/stores").StoreAction<unknown, (absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (result: string, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (failureReason: any, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<string>>;
+        ensureDocumentStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (result: DocumentMetadataStatus[], url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (failureReason: any, url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => Promise<DocumentMetadataStatus[]>>;
+        ensureDocumentSharepointStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: number[], libraryName: string) => void, (result: {
+            [key: number]: DocumentSharepointStatus;
+        }, url: string, params: number[], libraryName: string) => void, (failureReason: any, url: string, params: number[], libraryName: string) => void, (url: string, params: Array<number>, libraryName: string) => Promise<{
+            [key: number]: DocumentSharepointStatus;
+        }>>;
+        ensureDocumentTitleStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: number[], libraryName: string) => void, (result: {
+            [key: number]: string;
+        }, url: string, params: number[], libraryName: string) => void, (failureReason: any, url: string, params: number[], libraryName: string) => void, (url: string, params: Array<number>, libraryName: string) => Promise<{
+            [key: number]: string;
+        }>>;
+        ensurePublishedDocumentSharepointStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (result: PublishedDocumentSharepointStatus[], url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (failureReason: any, url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => Promise<PublishedDocumentSharepointStatus[]>>;
+        ensureRetoreDraftDocuments: import("@omnia/fx/stores").StoreAction<unknown, (documentIds: string[]) => void, (result: void, documentIds: string[]) => void, (failureReason: any, documentIds: string[]) => void, (documentIds: string[]) => Promise<void>>;
+    };
+    private getUserRolesKey;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

package/internal-do-not-import-from-here/stores/documentlibrary/NewDocumentStore.d.ts

@@ -0,0 +1,36 @@
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { SharePointField } from "../../models";
+/**
+ * The store is using for sharing data between tabs
+ * And we don't cache data here, we reload the latest document value everytime
+ *
+ * */
+export declare class NewDocumentStore extends Store {
+    private enterprisePropertyStore;
+    private enterprisePropertySetStore;
+    private teamAppPropertyService;
+    private documentTypeStore;
+    private documentTypeId;
+    private fields;
+    private loadSiteFieldsPromise;
+    getters: {
+        fields: () => SharePointField[];
+        documentTypeId: () => GuidValue;
+    };
+    mutations: {
+        setCurrentDocument: import("@omnia/fx/stores").StoreMutation<(fields: Array<SharePointField>) => void, (fields: SharePointField[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateDocumentTypeId: import("@omnia/fx/stores").StoreMutation<(id: GuidValue) => void, (id: GuidValue) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensureLoadFields: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    private getDocumentFieldsInSet;
+    private mergeDefaultValue;
+    private prepareDefaultValues;
+    private getSharePointFieldWithFromSiteDefaultValue;
+    private getSharePointFieldWithFixedDefaultValue;
+    private ensureLoadSitePropertiesFields;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,7 @@
+export * from "./DocumentTypeStore";
+export * from "./LibraryStore";
+export * from "./DocumentSharePointFieldStore";
+export * from "./DocumentTemplateStore";
+export * from "./NewDocumentStore";
+export * from "./DocumentPropetiesStore";
+export * from "./DocumentConversionStore";

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

@@ -5,3 +5,4 @@ export * from "./ProcessTypeStore";
 export * from "./SettingsStore";
 export * from "./ShapeTemplateStore";
 export * from "./ProcessTemplateLayoutStore";
+export * from "./documentlibrary";

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

@@ -1,7 +1,8 @@
-import { ProcessStep, Process, ProcessReference, RootProcessStep, InternalProcessStep, DrawingShapeDefinition } from "../fx/models";
+import { ProcessStep, Process, ProcessReference, RootProcessStep, InternalProcessStep, DrawingShapeDefinition } from "./models";
 import { GuidValue } from "@omnia/fx-models";
 import { MultilingualStore } from "@omnia/fx/stores";
 import { MultilingualString } from "@omnia/fx/models";
+import { RecentDocumentType } from "../models";
 export declare module OPMUtils {
     function generateProcessStepExpandState(processStep: RootProcessStep, processStepId: GuidValue): {
         [processStepId: string]: true;
@@ -26,4 +27,16 @@ export declare module OPMUtils {
     function parentFrameIsMsTeams(): boolean;
     function IsOpenEditorPreview(): boolean;
     function buildContextIdentifier(appId: GuidValue, processRoute: string): string;
+    function getMaximumLengthOfMultilingualString(multilingualString: MultilingualString): number;
+}
+export declare module ODMUtils {
+    function orderBy(input: any, [config]: [string?]): any;
+    function getOfficeClientPrefix(extension: string): string;
+    function addOfficeClientPrefix(url: string): string;
+    function saveRecentDocumentType(documentTypeId: GuidValue): void;
+    function getRecentDocumentTypes(): Array<RecentDocumentType>;
+    function isSupportedByOfficeWebApp(fileExtension: string): boolean;
+    function isSupportedByOfficeWebAppWithMsTeams(fileExtension: string): boolean;
+    function correctDateOnlyValue(dateValue: any): Date;
+    function isAllowedToConvertToPDF(fileExtension: string): boolean;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/management-system",
   "license": "MIT",
-  "version": "7.6.23-preview",
+  "version": "7.6.23",
   "description": "Omnia Management System.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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

@@ -1,33 +0,0 @@
-export declare const OPMEnterprisePropertyInternalNames: {
-    readonly OPMEdition: string;
-    readonly OPMRevision: string;
-    readonly OPMProcessType: string;
-    readonly OPMProcessIdNumber: string;
-    readonly OPMPublished: string;
-    readonly OPMApprovedBy: string;
-    readonly OPMIsArchived: string;
-    readonly OPMIsPublished: string;
-};
-export declare const OPMProcessProperty: {
-    readonly Id: string;
-};
-export declare module Security {
-    const OPMRoleDefinitions: {
-        readonly Author: string;
-        readonly Reader: string;
-        readonly Approver: string;
-        readonly Reviewer: string;
-    };
-    const OPMResourceEvaluators: {
-        readonly SecurityResourceIdResource: string;
-        readonly OPMProcessIdResource: string;
-    };
-    const Parameters: {
-        readonly OPMProcessId: string;
-        readonly SecurityResourceId: string;
-    };
-    const ODMRoleDefinitions: {
-        readonly AppInstanceAuthor: string;
-        readonly AppInstanceReader: string;
-    };
-}

package/internal-do-not-import-from-here/models/Constants.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Security = exports.OPMProcessProperty = exports.OPMEnterprisePropertyInternalNames = void 0;
-exports.OPMEnterprisePropertyInternalNames = {
-    get OPMEdition() { return "OPMEdition"; },
-    get OPMRevision() { return "OPMRevision"; },
-    get OPMProcessType() { return "OPMProcessType"; },
-    get OPMProcessIdNumber() { return "OPMProcessIdNumber"; },
-    get OPMPublished() { return "OPMPublished"; },
-    get OPMApprovedBy() { return "OPMApprovedBy"; },
-    get OPMIsArchived() { return "OPMIsArchived"; },
-    get OPMIsPublished() { return "OPMIsPublished"; }
-};
-exports.OPMProcessProperty = {
-    get Id() { return "7491ec1a-9cf5-4c49-b102-2f84f89795eb"; }
-};
-var Security;
-(function (Security) {
-    Security.OPMRoleDefinitions = {
-        get Author() { return "f412d0be-16e8-4fc2-80cf-dca39a265a08"; },
-        get Reader() { return "38c86dbf-44a2-45c4-b370-2c1cabea954c"; },
-        get Approver() { return "22672fb9-e62f-470c-a68d-77ae03a5115d"; },
-        get Reviewer() { return "89e89b72-a75c-41d2-8303-b83800980faa"; }
-    };
-    Security.OPMResourceEvaluators = {
-        get SecurityResourceIdResource() { return "Omnia.ManagementSystem.Web.Security.ResourceEvaluators.ISecurityResourceIdResourceEvaluator"; },
-        get OPMProcessIdResource() { return "Omnia.ManagementSystem.Web.Security.ResourceEvaluators.IOPMProcessIdResourceEvaluator"; }
-    };
-    Security.Parameters = {
-        get OPMProcessId() { return "opmProcessId"; },
-        get SecurityResourceId() { return "opmSecurityResourceId"; }
-    };
-    Security.ODMRoleDefinitions = {
-        get AppInstanceAuthor() { return "86c0c947-91e5-45aa-b85e-4ea8a9a31b07"; },
-        get AppInstanceReader() { return "cde81de4-58b0-4fe5-a45f-ed66138cb64c"; }
-    };
-})(Security = exports.Security || (exports.Security = {}));