@omnia/management-system 8.0.1-vnext → 8.0.3-dev

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

@@ -1,6 +1,7 @@
+import { guid } from "@omnia/fx/models";
 export interface ProcessMoveInfo {
     url: string;
     title: string;
     createdAt: number;
-    opmProcessId: string;
+    opmProcessId: guid;
 }

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

@@ -1,6 +1,6 @@
-import { GuidValue, PropertyIndexedType } from "@omnia/fx-models";
+import { guid, PropertyIndexedType } from "@omnia/fx-models";
 export interface ProcessPropertyInfo {
-    id: GuidValue;
+    id: guid;
     title: string;
     internalName: string;
     required?: boolean;

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

@@ -1,7 +1,7 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 export interface ProcessReference {
-    processId: GuidValue;
-    opmProcessId: GuidValue;
-    processStepId: GuidValue;
-    shortcutProcessStepId?: GuidValue;
+    processId: guid;
+    opmProcessId: guid;
+    processStepId: guid;
+    shortcutProcessStepId?: guid;
 }

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

@@ -1,10 +1,10 @@
 import { OmniaContext } from "@omnia/fx";
-import { ApiPath, GuidValue } from "@omnia/fx/models";
-export type ProcessTaskProviderId = GuidValue;
+import { ApiPath, guid } from "@omnia/fx/models";
+export type ProcessTaskProviderId = guid;
 export declare abstract class ProcessTaskProvider {
     id: ProcessTaskProviderId;
     title: string;
-    rendererManifestId: GuidValue;
+    rendererManifestId: guid;
     isRenderable: (omniaContext: OmniaContext) => boolean | Promise<boolean>;
 }
 export interface IProcessTaskApi {

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

@@ -1,10 +1,10 @@
-import { GuidValue, PropertyIndexedType } from "@omnia/fx-models";
+import { guid, PropertyIndexedType } from "@omnia/fx-models";
 import { ProcessPropertyInfo } from "./ProcessPropertyInfo";
 export interface ProcessTaxonomyPropertyInfo extends ProcessPropertyInfo {
     type: PropertyIndexedType.Taxonomy;
     multiple: boolean;
-    termSetId: GuidValue;
-    termIds: Array<GuidValue>;
+    termSetId: guid;
+    termIds: Array<guid>;
     parentInternalName?: string;
     limitLevel?: number;
 }

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

@@ -4,7 +4,7 @@ exports.ProcessTemplateLayoutDefinition = void 0;
 const models_1 = require("@omnia/fx/models");
 class ProcessTemplateLayoutDefinition extends models_1.VersionedLayoutDefinition {
     constructor() {
-        super("9b99018a-cd87-4292-9814-0d88820efa3a");
+        super((0, models_1.guid)("9b99018a-cd87-4292-9814-0d88820efa3a"));
         this.settings = {
             shapeDefinitions: [],
             canvas: {

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

@@ -7,4 +7,4 @@ var ProcessStepStatusType;
     ProcessStepStatusType[ProcessStepStatusType["InProgress"] = 1] = "InProgress";
     ProcessStepStatusType[ProcessStepStatusType["Completed"] = 2] = "Completed";
     ProcessStepStatusType[ProcessStepStatusType["OnHold"] = 3] = "OnHold";
-})(ProcessStepStatusType = exports.ProcessStepStatusType || (exports.ProcessStepStatusType = {}));
+})(ProcessStepStatusType || (exports.ProcessStepStatusType = ProcessStepStatusType = {}));

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

@@ -1,11 +1,11 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { Task } from "../data";
 import { GraphApiPlannerTask } from "../graph";
 export interface ProcessTaskAssignment {
-    taskId: GuidValue;
+    taskId: guid;
     contextIdentifier: string;
     data: ProcessTaskAssignmentData;
-    processId: GuidValue;
+    processId: guid;
 }
 export declare enum ProcessTaskAssignmentDataType {
     Planner = 0
@@ -19,7 +19,7 @@ export interface PlannerTaskAssignmentData extends ProcessTaskAssignmentData {
     taskId: string;
 }
 export interface CreatePlannerTaskAssignmentRequest {
-    processId: GuidValue;
+    processId: guid;
     contextIdentifier: string;
     planId: string;
     bucketId: string;
@@ -40,5 +40,5 @@ export interface GetPlannerTaskAssignmentResponse {
     plannerTasks: {
         [taskId: string]: GraphApiPlannerTask;
     };
-    unassignedTaskIds: GuidValue[];
+    unassignedTaskIds: guid[];
 }

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

@@ -4,4 +4,4 @@ exports.ProcessTaskAssignmentDataType = void 0;
 var ProcessTaskAssignmentDataType;
 (function (ProcessTaskAssignmentDataType) {
     ProcessTaskAssignmentDataType[ProcessTaskAssignmentDataType["Planner"] = 0] = "Planner";
-})(ProcessTaskAssignmentDataType = exports.ProcessTaskAssignmentDataType || (exports.ProcessTaskAssignmentDataType = {}));
+})(ProcessTaskAssignmentDataType || (exports.ProcessTaskAssignmentDataType = ProcessTaskAssignmentDataType = {}));

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/route/OPMRoute.d.ts

@@ -1,11 +1,11 @@
-import { TokenBasedRoute, GuidValue } from "@omnia/fx-models";
+import { TokenBasedRoute, guid } from "@omnia/fx-models";
 import { Version } from "../shared";
 export interface OPMRoute extends TokenBasedRoute {
     externalParents: Array<{
-        processStepId: GuidValue;
+        processStepId: guid;
         version?: Version;
     }>;
-    processStepId: GuidValue;
+    processStepId: guid;
     globalRenderer: boolean;
     /***
      * - NULL    :  Preview Version (defined in OPMSpecialRouteVersion)

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

@@ -1,6 +1,6 @@
 import { types } from "typestyle";
 import { OmniaTheming } from "@omnia/fx/ux";
-export declare module ProcessDesignerStyles {
+export declare namespace ProcessDesignerStyles {
     const PanelStyles: {
         settingsPanel?: (backgroundColor: any) => types.NestedCSSProperties;
         shortcutSettingsPanel?: types.NestedCSSProperties;

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

@@ -6,4 +6,4 @@ var ProcessDesignerStyles;
     ProcessDesignerStyles.PanelStyles = {};
     ProcessDesignerStyles.BlockWithToolbarStyles = {};
     ProcessDesignerStyles.ProcessDocumentsListingStyles = {};
-})(ProcessDesignerStyles = exports.ProcessDesignerStyles || (exports.ProcessDesignerStyles = {}));
+})(ProcessDesignerStyles || (exports.ProcessDesignerStyles = ProcessDesignerStyles = {}));

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

@@ -1,10 +1,10 @@
 import { types } from "typestyle";
-import { Theming, SpacingSettings } from "@omnia/fx-models";
+import { LegacyTheming, Spacing } from "@omnia/fx-models";
 export declare const ProcessNavigationBlockStyles: {
-    blockPadding?: (spacing: SpacingSettings) => types.NestedCSSProperties;
+    blockPadding?: (spacing: Spacing) => types.NestedCSSProperties;
     levelIndentationIconWrapper?: types.NestedCSSProperties;
     wrapper: types.NestedCSSProperties;
-    headerWrapper: (level: number, indentation: number, isRoutePath: boolean, theming: Theming, padding: SpacingSettings, 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/ShapeSelectionStyles.d.ts

@@ -3,7 +3,7 @@ import { OmniaTheming } from "@omnia/fx/ux";
 export declare const ShapeSelectionStyles: {
     shapesWrapper?: types.NestedCSSProperties;
     shapeDefinitionItem?: (size: number) => types.NestedCSSProperties;
-    canvasWrapper?: (theme: OmniaTheming, size: number) => types.NestedCSSProperties;
+    canvasWrapper?: (theme: OmniaTheming, size?: number) => types.NestedCSSProperties;
     iconWrapper?: (size: number) => types.NestedCSSProperties;
     selectionShapeWrapper?: (height: number) => types.NestedCSSProperties;
     canvasStyle?: types.NestedCSSProperties;

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

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

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

@@ -14,7 +14,6 @@ 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);

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/services/ImageService.d.ts

@@ -1,6 +1,6 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 export declare class ImageService {
     private opmHttpClient;
     constructor();
-    getLegacyShapeTemplateContent: (shapeTemplateId: GuidValue) => Promise<string>;
+    getLegacyShapeTemplateContent: (shapeTemplateId: guid) => Promise<string>;
 }

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

@@ -1,6 +1,8 @@
+import { guid } from "@omnia/fx/models";
 import { AuthorAndDefaultReaderUpdateInput } from "../models";
 export declare class PermissionService {
     private httpClient;
     constructor();
     updateOPMPermissions: (updateInput: AuthorAndDefaultReaderUpdateInput) => Promise<void>;
+    syncODMPermissions: (teamAppId: guid) => Promise<void>;
 }

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

@@ -1,11 +1,11 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ProcessDocumentRelationship, DocumentsRelatedProcesses, ProcessRelatedDocumentSuggestionEmail, ProcessRelatedControlledDocument } from "../models";
 export declare class ProcessDocumentRelationshipService {
     private httpClient;
     constructor();
     add: (relationship: ProcessDocumentRelationship) => Promise<ProcessDocumentRelationship>;
-    getProcessStepDocuments: (processId: GuidValue, processStepId: GuidValue, includeSuggestions?: boolean) => Promise<Array<ProcessRelatedControlledDocument>>;
-    delete: (processId: GuidValue, processStepId: GuidValue, documentIdNumber: number) => Promise<boolean>;
+    getProcessStepDocuments: (processId: guid, processStepId: guid, includeSuggestions?: boolean) => Promise<Array<ProcessRelatedControlledDocument>>;
+    delete: (processId: guid, processStepId: guid, documentIdNumber: number) => Promise<boolean>;
     getDocumentsRelatedProcesses: (documentIdNumbers: Array<number>, includeSuggestions?: boolean) => Promise<DocumentsRelatedProcesses[]>;
     sendSuggestionNotification: (suggestionEmail: ProcessRelatedDocumentSuggestionEmail) => Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ProcessFeedbackRecipients, ProcessFeedback } from "../models";
 export declare class ProcessFeedbackService {
     private httpClient;
     constructor();
     create: (feedback: ProcessFeedbackRecipients) => Promise<ProcessFeedback>;
-    getByOpmProcessId: (opmProcessId: GuidValue) => Promise<Array<ProcessFeedback>>;
-    remove: (id: GuidValue) => Promise<boolean>;
+    getByOpmProcessId: (opmProcessId: guid) => Promise<Array<ProcessFeedback>>;
+    remove: (id: guid) => Promise<boolean>;
 }

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

@@ -1,4 +1,4 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ProcessActionModel, Process, ProcessData, IdDict, ProcessCheckoutInfo, ProcessWithCheckoutInfo, Version, ProcessDataLayoutMergeResult } from "../models";
 import { ProcessLibraryStatus, ProcessSite } from "../../models";
 import { ProcessExportData } from "../models/data/processes/ProcessExportData";
@@ -9,40 +9,40 @@ export declare class ProcessService {
     constructor();
     checkIfDraftExists: (opmProcessId: string) => Promise<boolean>;
     createDraftProcess: (processActionModel: ProcessActionModel) => Promise<Process>;
-    createDraftProcessFromPublished: (opmProcessId: GuidValue, comment?: string) => Promise<Process>;
-    restoreProcess: (processId: GuidValue) => Promise<Process>;
-    checkinProcess: (opmProcessId: GuidValue) => Promise<Process>;
+    createDraftProcessFromPublished: (opmProcessId: guid, comment?: string) => Promise<Process>;
+    restoreProcess: (processId: guid) => Promise<Process>;
+    checkinProcess: (opmProcessId: guid) => Promise<Process>;
     saveCheckedOutProcess: (processActionModel: ProcessActionModel) => Promise<Process>;
-    getProcessCheckoutInfo: (opmProcessId: GuidValue) => Promise<ProcessCheckoutInfo>;
-    checkoutProcess: (opmProcessId: GuidValue, takeControl?: boolean) => Promise<ProcessWithCheckoutInfo>;
-    copyToNewProcess: (opmProcessId: GuidValue, processStepId: GuidValue) => Promise<Process>;
-    discardChangeProcess: (opmProcessId: GuidValue) => Promise<Process>;
-    getProcess: (processId: GuidValue) => Promise<Process>;
-    getProcessData: (opmProcessId: GuidValue, processStepId: GuidValue, hash: string) => Promise<ProcessData>;
-    getProcessDataLayoutMergeResult: (opmProcessId: GuidValue, processStepId: GuidValue, processDataHash: string, layoutHash: string, processTemplateVersionId: number) => Promise<ProcessDataLayoutMergeResult>;
-    getProcessDataExport: (processId: GuidValue) => Promise<ProcessExportData>;
-    deleteDraftProcess: (opmProcessId: GuidValue) => Promise<void>;
-    getArchivedOrPublishedProcessByProcessStepId: (processStepId: GuidValue, version: Version) => Promise<Process>;
-    permanentlyDeleteProcess: (opmProcessIds: GuidValue[]) => Promise<void>;
-    getPreviewProcessByProcessStepId: (processStepId: GuidValue) => Promise<ProcessWithCheckoutInfo>;
-    getDraftProcessesBySite: (teamAppId: GuidValue) => Promise<Process[]>;
-    getPublishedProcessesBySite: (teamAppId: GuidValue) => Promise<Process[]>;
-    getDraftProcessWorkingStatus: (teamAppId: GuidValue, opmProcessIds: Array<GuidValue>, isGetAll: boolean) => Promise<IdDict<ProcessLibraryStatus>>;
-    getPublishedProcessWorkingStatus: (teamAppId: GuidValue, opmProcessIds: Array<GuidValue>) => Promise<IdDict<ProcessLibraryStatus>>;
-    getRecycleBinWorkingStatus: (teamAppId: GuidValue, opmProcessIds: Array<GuidValue>) => Promise<IdDict<ProcessLibraryStatus>>;
-    checkIfDeletingProcessStepsAreBeingUsed: (processId: GuidValue, deletingProcessStepIds: Array<GuidValue>) => Promise<boolean>;
-    syncToSharePoint: (opmProcessId: GuidValue) => Promise<void>;
+    getProcessCheckoutInfo: (opmProcessId: guid) => Promise<ProcessCheckoutInfo>;
+    checkoutProcess: (opmProcessId: guid, takeControl?: boolean) => Promise<ProcessWithCheckoutInfo>;
+    copyToNewProcess: (opmProcessId: guid, processStepId: guid) => Promise<Process>;
+    discardChangeProcess: (opmProcessId: guid) => Promise<Process>;
+    getProcess: (processId: guid) => Promise<Process>;
+    getProcessData: (opmProcessId: guid, processStepId: guid, hash: string) => Promise<ProcessData>;
+    getProcessDataLayoutMergeResult: (opmProcessId: guid, processStepId: guid, processDataHash: string, layoutHash: string, processTemplateVersionId: number) => Promise<ProcessDataLayoutMergeResult>;
+    getProcessDataExport: (processId: guid) => Promise<ProcessExportData>;
+    deleteDraftProcess: (opmProcessId: guid) => Promise<void>;
+    getArchivedOrPublishedProcessByProcessStepId: (processStepId: guid, version: Version) => Promise<Process>;
+    permanentlyDeleteProcess: (opmProcessIds: guid[]) => Promise<void>;
+    getPreviewProcessByProcessStepId: (processStepId: guid) => Promise<ProcessWithCheckoutInfo>;
+    getDraftProcessesBySite: (teamAppId: guid) => Promise<Process[]>;
+    getPublishedProcessesBySite: (teamAppId: guid) => Promise<Process[]>;
+    getDraftProcessWorkingStatus: (teamAppId: guid, opmProcessIds: Array<guid>, isGetAll: boolean) => Promise<IdDict<ProcessLibraryStatus>>;
+    getPublishedProcessWorkingStatus: (teamAppId: guid, opmProcessIds: Array<guid>) => Promise<IdDict<ProcessLibraryStatus>>;
+    getRecycleBinWorkingStatus: (teamAppId: guid, opmProcessIds: Array<guid>) => Promise<IdDict<ProcessLibraryStatus>>;
+    checkIfDeletingProcessStepsAreBeingUsed: (processId: guid, deletingProcessStepIds: Array<guid>) => Promise<boolean>;
+    syncToSharePoint: (opmProcessId: guid) => Promise<void>;
     unpublishProcess: (opmProcessId: string) => Promise<boolean>;
-    triggerArchive: (opmProcessId: GuidValue) => Promise<void>;
-    triggerMove: (opmProcessId: GuidValue) => Promise<void>;
-    getProcessSiteByAppId: (teamAppId: GuidValue) => Promise<ProcessSite>;
-    getPublishedProcess: (opmProcessId: GuidValue) => Promise<Process>;
-    getDraftProcess: (opmProcessId: GuidValue) => Promise<Process>;
-    getProcessHistory: (opmProcessId: GuidValue) => Promise<Process[]>;
+    triggerArchive: (opmProcessId: guid) => Promise<void>;
+    triggerMove: (opmProcessId: guid) => Promise<void>;
+    getProcessSiteByAppId: (teamAppId: guid) => Promise<ProcessSite>;
+    getPublishedProcess: (opmProcessId: guid) => Promise<Process>;
+    getDraftProcess: (opmProcessId: guid) => Promise<Process>;
+    getProcessHistory: (opmProcessId: guid) => Promise<Process[]>;
     resolveAuthoringSite: (targetUrl: string) => Promise<ProcessSite>;
-    filterDeletedProcesses: (teamAppId: GuidValue) => Promise<Process[]>;
+    filterDeletedProcesses: (teamAppId: guid) => Promise<Process[]>;
     getPublishedProcessesAllSystem: () => Promise<Process[]>;
     private generateClientSideData;
     private setProcessStepMultilingualTitle;
-    setNewChangeCommentDraftProcess: (opmProcessId: GuidValue, comment: any) => Promise<void>;
+    setNewChangeCommentDraftProcess: (opmProcessId: guid, comment: any) => Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { CreatePlannerTaskAssignmentRequest, CreatePlannerTaskAssignmentResponse, GetPlannerTaskAssignmentRequest, GetPlannerTaskAssignmentResponse, GraphApiPlannerPlan } from "../models";
 export declare class ProcessTaskService {
     private httpClient;
     constructor();
-    getPlannerPlans: (groupId: GuidValue) => Promise<GraphApiPlannerPlan[]>;
+    getPlannerPlans: (groupId: guid) => Promise<GraphApiPlannerPlan[]>;
     getPlannerTaskAssignments: (request: GetPlannerTaskAssignmentRequest) => Promise<GetPlannerTaskAssignmentResponse>;
     addPlannerTaskAssignments: (request: CreatePlannerTaskAssignmentRequest) => Promise<CreatePlannerTaskAssignmentResponse>;
 }

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

@@ -1,12 +1,12 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ProcessTemplate } from "../models";
 export declare class ProcessTemplateService {
     private multilingualStore;
     private httpClient;
     constructor();
     getAllProcessTemplates: () => Promise<ProcessTemplate[]>;
-    getProcessTemplateById: (id: GuidValue) => Promise<ProcessTemplate>;
+    getProcessTemplateById: (id: guid) => Promise<ProcessTemplate>;
     addOrUpdateProcessTemplate: (processTemplate: ProcessTemplate) => Promise<ProcessTemplate>;
-    deleteProcessTemplate: (id: GuidValue) => Promise<boolean>;
+    deleteProcessTemplate: (id: guid) => Promise<boolean>;
     private generateProcessTemplatesMultilingualText;
 }

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

@@ -1,14 +1,14 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ProcessType } from "../models";
 export declare class ProcessTypeService {
     private httpClient;
     constructor();
     refreshServerCache: () => Promise<void>;
-    getByIds: (ids: Array<GuidValue>) => Promise<Array<ProcessType>>;
-    getChildren: (parentId: GuidValue) => Promise<Array<ProcessType>>;
-    getProcessTypeTermSetId: () => Promise<GuidValue>;
+    getByIds: (ids: Array<guid>) => Promise<Array<ProcessType>>;
+    getChildren: (parentId: guid) => Promise<Array<ProcessType>>;
+    getProcessTypeTermSetId: () => Promise<guid>;
     create: (processType: ProcessType) => Promise<ProcessType>;
     update: (processType: ProcessType) => Promise<ProcessType>;
-    remove: (id: GuidValue) => Promise<void>;
+    remove: (id: guid) => Promise<void>;
     getAllProcessTypeItems: () => Promise<ProcessType[]>;
 }

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

@@ -1,12 +1,12 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { ShapeTemplate } from "../models";
 export declare class ShapeTemplateService {
     private multilingualStore;
     private httpClient;
     constructor();
     getAllShapeTemplates: () => Promise<ShapeTemplate[]>;
-    getShapeTemplateById: (id: GuidValue) => Promise<ShapeTemplate>;
+    getShapeTemplateById: (id: guid) => Promise<ShapeTemplate>;
     addOrUpdateShapeTemplateItem: (shapeTemplate: ShapeTemplate) => Promise<ShapeTemplate>;
-    deleteShapeTemplate: (id: GuidValue) => Promise<void>;
+    deleteShapeTemplate: (id: guid) => Promise<void>;
     private generateShapeTemplatesMultilingualText;
 }

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 { guid } 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?: guid, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<string>;
+    updateDocumentFieldsStatus: (siteUrl: string, sqlId: guid, odmDocId: string, documentTypeId: guid) => Promise<SqlDocument>;
+    unlockFile: (webUrl: string, spDocumentId: number, sqlId: guid) => 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<guid>) => 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]: guid;
+    }, library: string): Promise<DocumentMetadataStatus[]>;
+    getRecycleBinDocumentsStatus(request: {
+        [key: string]: guid;
+    }): 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 { guid, Identity } from "@omnia/fx/models";
+import { DocumentType } from "../../../fx/models";
+export declare class DocumentTypeService {
+    private httpClient;
+    constructor();
+    refreshServerCache: () => Promise<void>;
+    getByIds: (ids: Array<guid>) => Promise<Array<DocumentType>>;
+    getChildren: (parentId?: guid) => Promise<Array<DocumentType>>;
+    getDocumentTypeTermSetId: () => Promise<guid>;
+    create: (documentType: DocumentType) => Promise<DocumentType>;
+    update: (documentType: DocumentType) => Promise<DocumentType>;
+    remove: (id: guid) => Promise<void>;
+    getUsersInApproverGroup: (docTypeId: guid, webUrl: string) => Promise<Identity[]>;
+    getByDocumentTemplateId: (documentTemplateId: guid) => 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 { guid } from "@omnia/fx/models";
+import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite, Enums } 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?: guid, documentId?: string, webUrl?: string, documentVersionType?: Enums.DocumentViewEnums.DocumentVersionType) => Promise<WorkflowHistory[]>;
+    isExistingDraftDocument: (webUrl: string, odmDocId: string) => Promise<boolean>;
+    resolveAuthoringSite: (webUrl: string) => Promise<SPSite>;
+}