@omnia/management-system 8.0.0-dev → 8.0.0-dev.562

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: guid;
 }
 export interface AppLayoutTargetControlIdentifier extends TargetControlIdentifier {

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

@@ -1,18 +1,18 @@
 import { MultilingualString } from "@omnia/fx-models";
 import { ShapeTemplateType, TextAlignment, TextPosition } from "../enums/Enums";
-import { ColorValue, guid } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 export interface DrawingShapeDefinitionProperties {
     shapeTemplateId: guid;
     shapeTemplateType: ShapeTemplateType;
-    backgroundColor: ColorValue;
-    borderColor: ColorValue;
-    textColor: ColorValue;
-    hoverBackgroundColor: ColorValue;
-    hoverBorderColor: ColorValue;
-    hoverTextColor: ColorValue;
-    selectedBackgroundColor: ColorValue;
-    selectedBorderColor: ColorValue;
-    selectedTextColor: ColorValue;
+    backgroundColor: string;
+    borderColor: string;
+    textColor: string;
+    hoverBackgroundColor: string;
+    hoverBorderColor: string;
+    hoverTextColor: string;
+    selectedBackgroundColor: string;
+    selectedBorderColor: string;
+    selectedTextColor: string;
     width: number;
     height: number;
     textPosition: TextPosition;

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

@@ -1,5 +1,4 @@
 import { MultilingualString, guid } from "@omnia/fx-models";
-import { useColorSchemaStore } 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(colors: ReturnType<typeof useColorSchemaStore>, 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,32 +14,3 @@ var ShapeMovingDirection;
     ShapeMovingDirection[ShapeMovingDirection["Left"] = 2] = "Left";
     ShapeMovingDirection[ShapeMovingDirection["Right"] = 3] = "Right";
 })(ShapeMovingDirection || (exports.ShapeMovingDirection = 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(colors, type) {
-        const shapeDefinition = {
-            type: type ? type : ShapeDefinitionTypes.Drawing,
-            title: { isMultilingualString: true },
-            id: (0, fx_models_1.guid)()
-        };
-        if (shapeDefinition.type == ShapeDefinitionTypes.Drawing) {
-            const drawingShapeDefinition = shapeDefinition;
-            drawingShapeDefinition.shapeTemplateId = constants_1.ShapeTemplatesConstants.Diamond.id;
-            drawingShapeDefinition.shapeTemplateType = constants_1.ShapeTemplatesConstants.Diamond.settings.type;
-            drawingShapeDefinition.title = constants_1.ShapeTemplatesConstants.Diamond.title;
-            drawingShapeDefinition.fontSize = 20;
-            drawingShapeDefinition.backgroundColor = colors.get.colorValue(colors.get.onBase.color);
-            drawingShapeDefinition.textColor = colors.get.colorValue(colors.get.base.color);
-            drawingShapeDefinition.width = 100;
-            drawingShapeDefinition.height = 100;
-            drawingShapeDefinition.textPosition = enums_1.TextPosition.On;
-            drawingShapeDefinition.textAlignment = enums_1.TextAlignment.Center;
-            drawingShapeDefinition.textHorizontalAdjustment = 0;
-            drawingShapeDefinition.textVerticalAdjustment = 0;
-        }
-        return shapeDefinition;
-    }
-};

package/internal-do-not-import-from-here/models/data/sharepoint/fields/SharePointDateTimeField.d.ts

@@ -4,4 +4,5 @@ export interface SharePointDateTimeField extends SharePointField {
     type: PropertyIndexedType.DateTime;
     value: Date;
     isDateOnly: boolean;
+    keepUtc: boolean;
 }

package/internal-do-not-import-from-here/models/data/sharepoint/fields/SharePointField.d.ts

@@ -18,4 +18,5 @@ export interface SharePointField {
     hidden?: boolean;
     type: PropertyIndexedType;
     description?: MultilingualString;
+    enterprisePropertyDefinitionId?: guid;
 }

package/internal-do-not-import-from-here/models/data/tasks/ApprovalTask.d.ts

@@ -4,4 +4,5 @@ export interface ApprovalTask extends DocumentTaskDetail {
     taskOutcome: Enums.DocumentViewEnums.ApprovalTaskOutcome;
     taskOutcomeText: string;
     workflow: Workflow;
+    scheduledPublishDate?: Date;
 }

package/internal-do-not-import-from-here/models/data/workflows/WorkflowHistory.d.ts

@@ -13,4 +13,5 @@ export interface WorkflowHistory {
     dueDate: Date;
     initiatorComment: string;
     workflowTasks: Array<WorkflowTaskHistory>;
+    scheduleWorkflow?: WorkflowHistory;
 }

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

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

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

@@ -13,9 +13,9 @@ 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("./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/messaging/ProcessRollupViewRegistration.d.ts

@@ -2,8 +2,8 @@ import { guid } from "@omnia/fx-models";
 export interface ProcessRollupViewRegistration {
     id: guid;
     title: string;
-    viewElement: string;
-    settingsElement: string;
+    componentManifestId: guid;
+    settingsComponentManifestId?: guid;
     supportScrollPaging?: boolean;
     supportClassicPaging?: boolean;
 }

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

@@ -0,0 +1,16 @@
+import { guid, Identity } from "@omnia/fx-models";
+import { ControlledDocument } from "../../../fx/models";
+export interface DocumentNotifiedPerson {
+    id: guid;
+    documentId: guid;
+    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/models/styles/ProcessNavigationBlockStyles.d.ts

@@ -1,10 +1,10 @@
 import { types } from "typestyle";
-import { Theming, Spacing } from "@omnia/fx-models";
+import { LegacyTheming, Spacing } from "@omnia/fx-models";
 export declare const ProcessNavigationBlockStyles: {
     blockPadding?: (spacing: Spacing) => types.NestedCSSProperties;
     levelIndentationIconWrapper?: types.NestedCSSProperties;
     wrapper: types.NestedCSSProperties;
-    headerWrapper: (level: number, indentation: number, isRoutePath: boolean, theming: Theming, padding: Spacing, isRightToLeft: boolean) => types.NestedCSSProperties;
+    headerWrapper: (level: number, indentation: number, isRoutePath: boolean, theming: LegacyTheming, padding: Spacing, isRightToLeft: boolean) => types.NestedCSSProperties;
     rightIcon: types.NestedCSSProperties;
     arrowBtnCollapsedDefault: types.NestedCSSProperties;
     arrowBtnExpanded: types.NestedCSSProperties;

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

@@ -11,9 +11,7 @@ export * from "./MediaPickerStyles";
 export * from "./ShapeGalleryDefaultSettingStyles";
 export * from "./FreeformPickerStyles";
 export * from "./TitleBlockStyles";
-export * from "./UnpublishProcessDialogStyles";
 export * from "./ProcessPickerStyles";
-export * from "./ProcessFieldDisplayStyles";
 export * from "./ProcessDesignerStyles";
 export * from "./ShapeSettingsStyles";
 export * from "./ProcessNavigationBlockStyles";

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

@@ -14,9 +14,7 @@ tslib_1.__exportStar(require("./MediaPickerStyles"), exports);
 tslib_1.__exportStar(require("./ShapeGalleryDefaultSettingStyles"), exports);
 tslib_1.__exportStar(require("./FreeformPickerStyles"), exports);
 tslib_1.__exportStar(require("./TitleBlockStyles"), exports);
-tslib_1.__exportStar(require("./UnpublishProcessDialogStyles"), exports);
 tslib_1.__exportStar(require("./ProcessPickerStyles"), exports);
-tslib_1.__exportStar(require("./ProcessFieldDisplayStyles"), exports);
 tslib_1.__exportStar(require("./ProcessDesignerStyles"), exports);
 tslib_1.__exportStar(require("./ShapeSettingsStyles"), exports);
 tslib_1.__exportStar(require("./ProcessNavigationBlockStyles"), 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 { useColorSchemaStore } 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(colors: ReturnType<typeof useColorSchemaStore>, 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/routing/OPMRouter.d.ts

@@ -8,6 +8,7 @@ export declare enum ProcessRendererOptions {
 declare class InternalOPMRouter extends TokenBasedRouter<OPMRoute, OPMRouteStateData> {
     private currentProcessStore;
     private multilingualStore;
+    private omniaCtx;
     private currentTitle;
     private currentProcessId;
     private currentProcessStepId;

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

@@ -23,7 +23,7 @@ export declare class DocumentService {
     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) => Promise<boolean>;
+    deletePublishDocument: (odmDocId: string, odmDocIdNumber: number, webUrl: string, documentTypeId: string, comment: string) => Promise<boolean>;
     getCurrentUserRolesOfListItems(request: DocumentRequest, library: string): Promise<{
         [key: number]: Enums.DocumentViewEnums.DocumentRoles[];
     }[]>;

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

@@ -1,5 +1,5 @@
 import { guid } from "@omnia/fx/models";
-import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite } from "../../models";
+import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite, Enums } from "../../models";
 export declare class DocumentLibraryService {
     private httpClient;
     private emptyHttpClient;
@@ -15,7 +15,7 @@ export declare class DocumentLibraryService {
     getTestFile: () => Promise<void>;
     mergeMetadataToDocument: (mergeRequest: MergeMetadataRequest, fileData: ArrayBuffer) => Promise<void>;
     testConvertToPDF: () => Promise<void>;
-    getWorkflowHistories: (sqlId: guid) => Promise<WorkflowHistory[]>;
+    getWorkflowHistories: (sqlId?: guid, documentId?: string, webUrl?: string, documentVersionType?: Enums.DocumentViewEnums.DocumentVersionType) => 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

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

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

@@ -7,5 +7,6 @@ export declare class TaskService {
     getFilterTasks: (request: TaskRequest) => Promise<TaskItemResponse>;
     getTaskById: (webUrl: string, taskId: number) => Promise<DocumentTaskDetail>;
     getDocumentWorkflow: (spDocumentId: number, sqlId: guid, webUrl: string, workflowType?: Enums.DocumentViewEnums.WorkflowType) => Promise<Workflow>;
+    getDocumentWorkflowByType: (sqlId: guid, workflowType: Enums.DocumentViewEnums.WorkflowType) => Promise<Workflow>;
     deleteTask: (webUrl: string, spId: number) => Promise<void>;
 }

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

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Store } from "@omnia/fx/stores";
 import { PermissionService } from "@omnia/fx/services";
 import { guid, MultilingualString } from "@omnia/fx-models";
@@ -22,8 +20,8 @@ export declare class CurrentProcessStore extends Store {
     getters: {
         processReference: () => ProcessReference;
         referenceData: () => ProcessReferenceData;
-        onCurrentProcessReferenceDataMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessReferenceData>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-        onCurrentProcessReferenceMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessReference>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onCurrentProcessReferenceDataMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessReferenceData>) => void | Promise<void>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onCurrentProcessReferenceMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessReference>) => void | Promise<void>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         relevantProcess: (processStepId: guid) => {
             process: Process;
             processStepIdDict: IdDict<boolean>;

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

@@ -3,7 +3,6 @@ import { guid, MediaPickerImage } from "@omnia/fx-models";
 import { MoveProcessService } from "../services";
 import { ProcessActionModel, Process, ProcessReference, ProcessReferenceData, ProcessCheckoutInfo, ProcessWithCheckoutInfo, Version, ProcessMoveInfo, ProcessDataLayoutMergeResult, ProcessStep } from "../models";
 import { ProcessSite } from "../../models";
-import { MediaPickerService } from "@omnia/fx/services";
 import { ProcessTemplateLayoutStore } from "./ProcessTemplateLayoutStore";
 interface ProcessMoveInfoDict {
     [opmProcessId: string]: ProcessMoveInfo;
@@ -17,7 +16,37 @@ interface NotificationMessage {
 export declare class ProcessStore extends Store {
     private processService;
     moveProcessService: MoveProcessService;
-    mediaPickerService: MediaPickerService;
+    mediaPickerStore: {
+        get: {
+            readonly imageRatios: Array<MediaPickerImageRatio>;
+            imageRatioByUniqueId(uniqueId: guid): MediaPickerImageRatio;
+            readonly rollupRatios: Array<MediaPickerRollupImageRatio>;
+            readonly imageScalings: Array<MediaPickerImageScaling>;
+            imageScalingByUniqueId(uniqueId: guid): MediaPickerImageScaling;
+            readonly providers: Array<MediaPickerProvider>;
+            url: (media: MediaPickerImage | import("@omnia/fx-models").MediaPickerVideo, ratioId?: guid) => string;
+            imageUrl: (mediapickerImage: MediaPickerImage, imageRatioId?: number, scalingId?: number, useWithToken?: boolean) => string;
+        };
+        actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+            registerMediaPickerProvider(provider: MediaPickerProvider | Array<MediaPickerProvider>): void;
+            registerMediaPickerConfigurationHook(filterFunc: (current: Array<MediaPickerProvider>) => Array<MediaPickerProvider>): void;
+            ensureImageScalings(): Promise<void>;
+            addImageScaling(imageScalingDefinition: MediaPickerImageScalingDefinition): Promise<void>;
+            updateImageScaling(imageScalingToUpdate: MediaPickerImageScaling, newImageScalingDefinition: MediaPickerImageScalingDefinition): Promise<void>;
+            deleteImageScaling(imageScalingToDelete: MediaPickerImageScaling): Promise<void>;
+            ensureImageRatios(): Promise<void>;
+            addImageRatio(ratioDefinition: MediaPickerImageRatioDefinition): Promise<void>;
+            updateImageRatio(ratioToUpdate: MediaPickerImageRatio, newTitle: import("@omnia/fx-models").MultilingualString, enableInRollup: boolean): Promise<void>;
+            deleteImageRatio(ratioToDelete: MediaPickerImageRatio): Promise<void>;
+        }>;
+        events: import("@omnia/fx/stores").StoreEvents<{
+            imageRatios: MediaPickerImageRatio[];
+            imageScalings: MediaPickerImageScaling[];
+            providers: MediaPickerProvider[];
+        }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+    } & {
+        dispose?: () => void;
+    };
     processTemplateLayoutStore: ProcessTemplateLayoutStore;
     private processDict;
     private processCheckoutInfoDict;
@@ -39,7 +68,7 @@ export declare class ProcessStore extends Store {
         getProcessReferenceData: (processReference: ProcessReference) => ProcessReferenceData;
         processCheckoutInfo: (opmProcessId: guid) => ProcessCheckoutInfo;
         process: (processId: guid) => Process;
-        processMoveSiteInfoDictOnMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessMoveInfoDict>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        processMoveSiteInfoDictOnMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessMoveInfoDict>) => void | Promise<void>) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
         processMoveSiteInfo: (opmProcessId: guid) => ProcessMoveInfo;
         processMoveSiteInfoDict: () => ProcessMoveInfoDict;
         getImageUrl: (image: MediaPickerImage, imageUrl?: string) => string;

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

@@ -6,15 +6,15 @@ export declare class SettingsStore extends Store {
     private settings;
     getters: {
         getByModel: <T extends Setting>(model: new () => T) => T;
-        getByDynamicKeyModel: <T_1 extends DynamicKeySetting>(model: new (dynamicKey: string) => T_1, dynamicKey: string) => T_1;
+        getByDynamicKeyModel: <T extends DynamicKeySetting>(model: new (dynamicKey: string) => T, dynamicKey: string) => T;
     };
     private mutations;
     actions: {
         ensureSettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new () => Setting) => void, (result: null, model: new () => Setting) => void, (failureReason: any, model: new () => Setting) => void, <T extends Setting>(model: new () => T) => Promise<null>>;
-        ensureDynamicKeySettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (result: null, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (failureReason: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, <T_1 extends DynamicKeySetting>(model: new (dynamicKey: string) => T_1, dynamicKey: string) => Promise<null>>;
-        addOrUpdateSettings: import("@omnia/fx/stores").StoreAction<unknown, (settings: Setting) => void, (result: any, settings: Setting) => void, (failureReason: any, settings: Setting) => void, <T_2 extends Setting>(settings: T_2) => Promise<any>>;
-        removeSettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new () => Setting) => void, (result: any, model: new () => Setting) => void, (failureReason: any, model: new () => Setting) => void, <T_3 extends Setting>(model: new () => T_3) => Promise<any>>;
-        removeDynamicKeySettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (result: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (failureReason: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, <T_4 extends DynamicKeySetting>(model: new (dynamicKey: string) => T_4, dynamicKey: string) => Promise<any>>;
+        ensureDynamicKeySettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (result: null, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (failureReason: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, <T extends DynamicKeySetting>(model: new (dynamicKey: string) => T, dynamicKey: string) => Promise<null>>;
+        addOrUpdateSettings: import("@omnia/fx/stores").StoreAction<unknown, (settings: Setting) => void, (result: any, settings: Setting) => void, (failureReason: any, settings: Setting) => void, <T extends Setting>(settings: T) => Promise<any>>;
+        removeSettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new () => Setting) => void, (result: any, model: new () => Setting) => void, (failureReason: any, model: new () => Setting) => void, <T extends Setting>(model: new () => T) => Promise<any>>;
+        removeDynamicKeySettings: import("@omnia/fx/stores").StoreAction<unknown, (model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (result: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, (failureReason: any, model: new (dynamicKey: string) => DynamicKeySetting, dynamicKey: string) => void, <T extends DynamicKeySetting>(model: new (dynamicKey: string) => T, dynamicKey: string) => Promise<any>>;
     };
     protected onActivated(): void;
     protected onDisposing(): void;

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

@@ -34,6 +34,7 @@ export declare class DocumentTypeStore extends Store {
         ensureDocumentTypes: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeIds: guid[]) => void, (result: any, documentTypeIds: guid[]) => void, (failureReason: any, documentTypeIds: guid[]) => void, (documentTypeIds: Array<guid>) => 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: guid) => void, (result: DocumentType[], documentTemplateId: guid) => void, (failureReason: any, documentTemplateId: guid) => void, (documentTemplateId: guid) => Promise<DocumentType[]>>;
+        getSpecificDocumentTypeById: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeId: guid) => void, (result: unknown, documentTypeId: guid) => void, (failureReason: any, documentTypeId: guid) => void, (documentTypeId: guid) => Promise<unknown>>;
     };
     private isRootParentId;
     private getParentId;

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

@@ -24,9 +24,9 @@ export declare class LibraryStore extends Store {
         isLoadingDraft: () => boolean;
         isLoadingPublished: () => boolean;
         isLoadingRecycleBin: () => boolean;
-        listItemsUserRoles: (library: string, id: number) => {
-            [key: string]: Enums.DocumentViewEnums.DocumentRoles[];
-        }[];
+        listItemsUserRoles: (library: string, id: number) => Array<{
+            [key: string]: Array<Enums.DocumentViewEnums.DocumentRoles>;
+        }>;
         publishedLibraryUserRoles: () => Array<Enums.DocumentViewEnums.DocumentRoles>;
         getDocumentStatus: (documents: Array<DocumentMetadataStatus>, siteUrl: string) => Array<DocumentMetadataStatus>;
         isCreatingDraftStatus: (key: string) => boolean;
@@ -34,9 +34,9 @@ export declare class LibraryStore extends Store {
     };
     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: {
+        setListItemsUserRoles: import("@omnia/fx/stores").StoreMutation<(library: string, ids: number[], userRoles: Array<{
+            [id: number]: Array<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>;

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

@@ -27,10 +27,12 @@ export declare namespace OPMUtils {
     function parentFrameIsMsTeams(): boolean;
     function IsOpenEditorPreview(): boolean;
     function buildContextIdentifier(appId: guid, processRoute: string): string;
+    function getMaximumLengthOfMultilingualString(multilingualString: MultilingualString): number;
 }
 export declare namespace ODMUtils {
     function orderBy(input: any, [config]: [string?]): any;
     function getOfficeClientPrefix(extension: string): string;
+    function addOfficeClientPrefix(url: string): string;
     function saveRecentDocumentType(documentTypeId: guid): void;
     function getRecentDocumentTypes(): Array<RecentDocumentType>;
     function isSupportedByOfficeWebApp(fileExtension: string): boolean;

package/internal-do-not-import-from-here/ux/filterengine/components/renderer/process/ProcessPropertyRenderer.d.ts

@@ -1,10 +1,14 @@
 import ProcessFilterEngineHandler from "../../../handler/ProcessFilterEngineHandler";
 declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
         typedHandler: import("vue").Prop<ProcessFilterEngineHandler, ProcessFilterEngineHandler>;
-    }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        typedHandler: import("vue").Prop<ProcessFilterEngineHandler, ProcessFilterEngineHandler>;
-    }>>, {}, true, {}, {}, {
+        onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+        onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+    }>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -13,14 +17,32 @@ declare const _default: {
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
         typedHandler: import("vue").Prop<ProcessFilterEngineHandler, ProcessFilterEngineHandler>;
-    }>>, () => JSX.Element, {}, {}, {}, {}>;
+        onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+        onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+        onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+    }>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     typedHandler: import("vue").Prop<ProcessFilterEngineHandler, ProcessFilterEngineHandler>;
-}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+    onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+    onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+    onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+    onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
+    onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
+}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
+        onVnodeBeforeMount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeBeforeUpdate?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+        onVnodeMounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
         typedHandler?: ProcessFilterEngineHandler;
     }>, never>;
 };