@omnia/management-system 7.11.0-preview.3 → 8.0.0-dev.561

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/shapedefinitions/ShapeDefinitionData.d.ts

@@ -1,9 +1,9 @@
-import { OmniaTheming } from "@omnia/fx/ux";
+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(theming: OmniaTheming, type?: ShapeDefinitionTypes): ShapeDefinition;
+    createDefaultProcessTemplate(colors: ReturnType<typeof useColorSchemaStore>, type?: ShapeDefinitionTypes): ShapeDefinition;
 };

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,8 +1,8 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { AuthorAndDefaultReaderUpdateInput } from "../models";
 export declare class PermissionService {
     private httpClient;
     constructor();
     updateOPMPermissions: (updateInput: AuthorAndDefaultReaderUpdateInput) => Promise<void>;
-    syncODMPermissions: (teamAppId: GuidValue) => 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/document/DocumentService.d.ts

@@ -1,15 +1,15 @@
-import { GuidValue } from "@omnia/fx/models";
+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?: GuidValue, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest, isUpdateScheduledPublishing?: boolean) => Promise<string>;
-    updateDocumentFieldsStatus: (siteUrl: string, sqlId: GuidValue, odmDocId: string, documentTypeId: GuidValue) => Promise<SqlDocument>;
-    unlockFile: (webUrl: string, spDocumentId: number, sqlId: GuidValue) => Promise<boolean>;
+    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<GuidValue>) => Promise<void>;
+    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>>;
@@ -31,10 +31,10 @@ export declare class DocumentService {
     canCurrentUserEditLibraryDocument: (webUrl: string, libraryName: string) => Promise<boolean>;
     getExpireReviewsDocuments: (request: PagingRequest) => Promise<GetControlledDocumentsResponse>;
     getDocumentsStatus(request: {
-        [key: string]: GuidValue;
+        [key: string]: guid;
     }, library: string): Promise<DocumentMetadataStatus[]>;
     getRecycleBinDocumentsStatus(request: {
-        [key: string]: GuidValue;
+        [key: string]: guid;
     }): Promise<DocumentMetadataStatus[]>;
     getPublishedDocumentsSharepointStatus(request: {
         [key: number]: number;

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

@@ -1,15 +1,15 @@
-import { GuidValue, Identity } from "@omnia/fx/models";
-import { DocumentType } from "../../models";
+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<GuidValue>) => Promise<Array<DocumentType>>;
-    getChildren: (parentId?: GuidValue) => Promise<Array<DocumentType>>;
-    getDocumentTypeTermSetId: () => Promise<GuidValue>;
+    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: GuidValue) => Promise<void>;
-    getUsersInApproverGroup: (docTypeId: GuidValue, webUrl: string) => Promise<Identity[]>;
-    getByDocumentTemplateId: (documentTemplateId: GuidValue) => Promise<Array<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

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

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

@@ -1,4 +1,4 @@
-import { GuidValue } from "@omnia/fx/models";
+import { guid } from "@omnia/fx/models";
 import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite, Enums } from "../../models";
 export declare class DocumentLibraryService {
     private httpClient;
@@ -15,7 +15,7 @@ export declare class DocumentLibraryService {
     getTestFile: () => Promise<void>;
     mergeMetadataToDocument: (mergeRequest: MergeMetadataRequest, fileData: ArrayBuffer) => Promise<void>;
     testConvertToPDF: () => Promise<void>;
-    getWorkflowHistories: (sqlId?: GuidValue, documentId?: string, webUrl?: string, documentVersionType?: Enums.DocumentViewEnums.DocumentVersionType) => 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,18 +1,18 @@
-import { GuidValue } from "@omnia/fx/models";
-import { DocumentNotifiedPerson, DocumentReadReceiptsHistory, Enums, PublishDocumentWithoutApprovalRequest, MoveDocumentToTargetSiteRequest, PreviewPublishedDocumentRequest, ControlledDocument } from "../../models";
+import { guid } from "@omnia/fx/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: GuidValue) => Promise<void>;
-    checkPrePublishCondition: (webUrl: string, spDocumentId: number, sqlId: GuidValue, status: Enums.DocumentViewEnums.LibraryDocumentStatus) => Promise<boolean>;
-    validateUnacceptedChange: (webUrl: string, spDocumentId: number, sqlId: GuidValue, status: Enums.DocumentViewEnums.LibraryDocumentStatus) => Promise<boolean>;
+    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: GuidValue) => 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: GuidValue, isReadAndUnderstood: boolean) => Promise<void>;
+    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

@@ -1,12 +1,12 @@
-import { GuidValue } from "@omnia/fx/models";
-import { Workflow, DocumentTaskDetail, TaskRequest, TaskItemResponse, Enums } from "../../models";
+import { guid } from "@omnia/fx/models";
+import { Workflow, DocumentTaskDetail, TaskRequest, TaskItemResponse, Enums } from "../../../fx/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>;
-    getDocumentWorkflowByType: (sqlId: GuidValue, workflowType: Enums.DocumentViewEnums.WorkflowType) => Promise<Workflow>;
+    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/services/documentlibrary/index.d.ts

@@ -4,4 +4,3 @@ export * from "./ReviewTaskService";
 export * from "./PublishDocumentService";
 export * from "./ReviewReminderTaskService";
 export * from "./ApprovalTaskService";
-export * from "./RelatedDocumentsService";

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

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 import { Store } from "@omnia/fx/stores";
 import { PermissionService } from "@omnia/fx/services";
-import { GuidValue, MultilingualString } from "@omnia/fx-models";
+import { guid, MultilingualString } from "@omnia/fx-models";
 import { ProcessReference, ProcessReferenceData, Process, IdDict, InternalProcessStep, ExternalProcessStep, Version } from "../models";
 import { Layout } from "@omnia/fx/models";
 export declare class CurrentProcessStore extends Store {
@@ -21,9 +20,9 @@ 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;
-        relevantProcess: (processStepId: GuidValue) => {
+        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>;
         };
@@ -36,8 +35,8 @@ export declare class CurrentProcessStore extends Store {
     actions: {
         setProcessToShow: import("@omnia/fx/stores").StoreAction<unknown, (processReferenceToUse: ProcessReference) => void, (result: null, processReferenceToUse: ProcessReference) => void, (failureReason: any, processReferenceToUse: ProcessReference) => void, (processReferenceToUse: ProcessReference) => Promise<null>>;
         initCurrentProcessDataLayout: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
-        ensureShortcut: import("@omnia/fx/stores").StoreAction<unknown, (shortcutProcessStepId: GuidValue) => void, (result: null, shortcutProcessStepId: GuidValue) => void, (failureReason: any, shortcutProcessStepId: GuidValue) => void, (shortcutProcessStepId: GuidValue) => Promise<null>>;
-        ensureRelevantProcess: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: GuidValue, version: Version) => void, (result: Process, processStepId: GuidValue, version: Version) => void, (failureReason: any, processStepId: GuidValue, version: Version) => void, (processStepId: GuidValue, version: Version) => Promise<Process>>;
+        ensureShortcut: import("@omnia/fx/stores").StoreAction<unknown, (shortcutProcessStepId: guid) => void, (result: null, shortcutProcessStepId: guid) => void, (failureReason: any, shortcutProcessStepId: guid) => void, (shortcutProcessStepId: guid) => Promise<null>>;
+        ensureRelevantProcess: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: guid, version: Version) => void, (result: Process, processStepId: guid, version: Version) => void, (failureReason: any, processStepId: guid, version: Version) => void, (processStepId: guid, version: Version) => Promise<Process>>;
         checkOut: import("@omnia/fx/stores").StoreAction<unknown, (takeControl?: boolean) => void, (result: null, takeControl?: boolean) => void, (failureReason: any, takeControl?: boolean) => void, (takeControl?: boolean) => Promise<null>>;
         checkIn: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
         deleteProcessStep: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
@@ -48,10 +47,10 @@ export declare class CurrentProcessStore extends Store {
             process: Process;
             processStep: InternalProcessStep;
         }>>;
-        addExtenalProcessStep: import("@omnia/fx/stores").StoreAction<unknown, (title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (result: {
+        addExtenalProcessStep: import("@omnia/fx/stores").StoreAction<unknown, (title: MultilingualString, externalRootProcessStepId: guid) => void, (result: {
             process: Process;
             processStep: ExternalProcessStep;
-        }, title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (failureReason: any, title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (title: MultilingualString, externalRootProcessStepId: GuidValue) => Promise<{
+        }, title: MultilingualString, externalRootProcessStepId: guid) => void, (failureReason: any, title: MultilingualString, externalRootProcessStepId: guid) => void, (title: MultilingualString, externalRootProcessStepId: guid) => Promise<{
             process: Process;
             processStep: ExternalProcessStep;
         }>>;

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

@@ -1,9 +1,8 @@
 import { Store } from "@omnia/fx/stores";
-import { GuidValue, MediaPickerImage } from "@omnia/fx-models";
+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;
@@ -37,40 +66,40 @@ export declare class ProcessStore extends Store {
     readonly moveMessageTimeout = 10000;
     getters: {
         getProcessReferenceData: (processReference: ProcessReference) => ProcessReferenceData;
-        processCheckoutInfo: (opmProcessId: GuidValue) => ProcessCheckoutInfo;
-        process: (processId: GuidValue) => Process;
-        processMoveSiteInfoDictOnMutated: () => (fn: (obj: import("@omnia/fx-models").StateMutation<ProcessMoveInfoDict>) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-        processMoveSiteInfo: (opmProcessId: GuidValue) => ProcessMoveInfo;
+        processCheckoutInfo: (opmProcessId: guid) => ProcessCheckoutInfo;
+        process: (processId: guid) => Process;
+        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;
         getAllDraftPublishedProcesses: () => Array<Process>;
-        getDraftProcesses: (teamAppId: GuidValue) => Process[];
+        getDraftProcesses: (teamAppId: guid) => Process[];
         getPublishedProcesses: () => Process[];
     };
     mutations: {
         removeProcessMoveSiteInfoDict: import("@omnia/fx/stores").StoreMutation<(removeDict: ProcessMoveInfoDict) => void, (removeDict: ProcessMoveInfoDict) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
-        createDraft: import("@omnia/fx/stores").StoreAction<unknown, (actionModel: ProcessActionModel) => void, (result: Process, actionModel: ProcessActionModel) => void, (failureReason: any, actionModel: ProcessActionModel) => void, (actionModel: ProcessActionModel) => Promise<Process>>;
-        createDraftFromPublished: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, comment?: string) => void, (result: Process, opmProcessId: GuidValue, comment?: string) => void, (failureReason: any, opmProcessId: GuidValue, comment?: string) => void, (opmProcessId: GuidValue, comment?: string) => Promise<Process>>;
-        restoreProcess: import("@omnia/fx/stores").StoreAction<unknown, (processId: GuidValue) => void, (result: Process, processId: GuidValue) => void, (failureReason: any, processId: GuidValue) => void, (processId: GuidValue) => Promise<Process>>;
-        checkoutProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, takeControl?: boolean) => void, (result: ProcessWithCheckoutInfo, opmProcessId: GuidValue, takeControl?: boolean) => void, (failureReason: any, opmProcessId: GuidValue, takeControl?: boolean) => void, (opmProcessId: GuidValue, takeControl?: boolean) => Promise<ProcessWithCheckoutInfo>>;
-        checkInProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue) => void, (result: Process, opmProcessId: GuidValue) => void, (failureReason: any, opmProcessId: GuidValue) => void, (opmProcessId: GuidValue) => Promise<Process>>;
-        discardChangeProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue) => void, (result: Process, opmProcessId: GuidValue) => void, (failureReason: any, opmProcessId: GuidValue) => void, (opmProcessId: GuidValue) => Promise<Process>>;
+        createDraft: import("@omnia/fx/stores").StoreAction<unknown, (actionModel: ProcessActionModel) => void, (result: unknown, actionModel: ProcessActionModel) => void, (failureReason: any, actionModel: ProcessActionModel) => void, (actionModel: ProcessActionModel) => Promise<unknown>>;
+        createDraftFromPublished: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, comment?: string) => void, (result: unknown, opmProcessId: guid, comment?: string) => void, (failureReason: any, opmProcessId: guid, comment?: string) => void, (opmProcessId: guid, comment?: string) => Promise<unknown>>;
+        restoreProcess: import("@omnia/fx/stores").StoreAction<unknown, (processId: guid) => void, (result: unknown, processId: guid) => void, (failureReason: any, processId: guid) => void, (processId: guid) => Promise<unknown>>;
+        checkoutProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, takeControl?: boolean) => void, (result: ProcessWithCheckoutInfo, opmProcessId: guid, takeControl?: boolean) => void, (failureReason: any, opmProcessId: guid, takeControl?: boolean) => void, (opmProcessId: guid, takeControl?: boolean) => Promise<ProcessWithCheckoutInfo>>;
+        checkInProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid) => void, (result: Process, opmProcessId: guid) => void, (failureReason: any, opmProcessId: guid) => void, (opmProcessId: guid) => Promise<Process>>;
+        discardChangeProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid) => void, (result: Process, opmProcessId: guid) => void, (failureReason: any, opmProcessId: guid) => void, (opmProcessId: guid) => Promise<Process>>;
         saveCheckedOutProcess: import("@omnia/fx/stores").StoreAction<unknown, (actionModel: ProcessActionModel) => void, (result: Process, actionModel: ProcessActionModel) => void, (failureReason: any, actionModel: ProcessActionModel) => void, (actionModel: ProcessActionModel) => Promise<Process>>;
-        ensurePublishedProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, refreshCache?: boolean) => void, (result: Process, opmProcessId: GuidValue, refreshCache?: boolean) => void, (failureReason: any, opmProcessId: GuidValue, refreshCache?: boolean) => void, (opmProcessId: GuidValue, refreshCache?: boolean) => Promise<Process>>;
-        ensureDraftProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, refreshCache?: boolean) => void, (result: Process, opmProcessId: GuidValue, refreshCache?: boolean) => void, (failureReason: any, opmProcessId: GuidValue, refreshCache?: boolean) => void, (opmProcessId: GuidValue, refreshCache?: boolean) => Promise<Process>>;
-        ensureProcessCheckoutInfo: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue) => void, (result: ProcessCheckoutInfo, opmProcessId: GuidValue) => void, (failureReason: any, opmProcessId: GuidValue) => void, (opmProcessId: GuidValue) => Promise<ProcessCheckoutInfo>>;
+        ensurePublishedProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, refreshCache?: boolean) => void, (result: Process, opmProcessId: guid, refreshCache?: boolean) => void, (failureReason: any, opmProcessId: guid, refreshCache?: boolean) => void, (opmProcessId: guid, refreshCache?: boolean) => Promise<Process>>;
+        ensureDraftProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, refreshCache?: boolean) => void, (result: Process, opmProcessId: guid, refreshCache?: boolean) => void, (failureReason: any, opmProcessId: guid, refreshCache?: boolean) => void, (opmProcessId: guid, refreshCache?: boolean) => Promise<Process>>;
+        ensureProcessCheckoutInfo: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid) => void, (result: unknown, opmProcessId: guid) => void, (failureReason: any, opmProcessId: guid) => void, (opmProcessId: guid) => Promise<unknown>>;
         ensureProcessReferenceData: import("@omnia/fx/stores").StoreAction<unknown, (processReferences: ProcessReference[]) => void, (result: null, processReferences: ProcessReference[]) => void, (failureReason: any, processReferences: ProcessReference[]) => void, (processReferences: Array<ProcessReference>) => Promise<null>>;
         ensureProcessDataMergedLayout: import("@omnia/fx/stores").StoreAction<unknown, (process: Process, processStep: ProcessStep) => void, (result: ProcessDataLayoutMergeResult, process: Process, processStep: ProcessStep) => void, (failureReason: any, process: Process, processStep: ProcessStep) => void, (process: Process, processStep: ProcessStep) => Promise<ProcessDataLayoutMergeResult>>;
-        loadProcessByProcessStepId: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: GuidValue, version: Version) => void, (result: Process, processStepId: GuidValue, version: Version) => void, (failureReason: any, processStepId: GuidValue, version: Version) => void, (processStepId: GuidValue, version: Version) => Promise<Process>>;
-        loadPreviewProcessByProcessStepId: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: GuidValue) => void, (result: ProcessWithCheckoutInfo, processStepId: GuidValue) => void, (failureReason: any, processStepId: GuidValue) => void, (processStepId: GuidValue) => Promise<ProcessWithCheckoutInfo>>;
+        loadProcessByProcessStepId: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: guid, version: Version) => void, (result: Process, processStepId: guid, version: Version) => void, (failureReason: any, processStepId: guid, version: Version) => void, (processStepId: guid, version: Version) => Promise<Process>>;
+        loadPreviewProcessByProcessStepId: import("@omnia/fx/stores").StoreAction<unknown, (processStepId: guid) => void, (result: ProcessWithCheckoutInfo, processStepId: guid) => void, (failureReason: any, processStepId: guid) => void, (processStepId: guid) => Promise<ProcessWithCheckoutInfo>>;
         deleteDraftProcess: import("@omnia/fx/stores").StoreAction<unknown, (process: Process) => void, (result: null, process: Process) => void, (failureReason: any, process: Process) => void, (process: Process) => Promise<null>>;
-        copyToNewProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, processStepId: GuidValue) => void, (result: Process, opmProcessId: GuidValue, processStepId: GuidValue) => void, (failureReason: any, opmProcessId: GuidValue, processStepId: GuidValue) => void, (opmProcessId: GuidValue, processStepId: GuidValue) => Promise<Process>>;
-        moveProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, title: string, targetSite: ProcessSite) => void, (result: boolean, opmProcessId: GuidValue, title: string, targetSite: ProcessSite) => void, (failureReason: any, opmProcessId: GuidValue, title: string, targetSite: ProcessSite) => void, (opmProcessId: GuidValue, title: string, targetSite: ProcessSite) => Promise<boolean>>;
-        ensureLoadDraftProcesses: import("@omnia/fx/stores").StoreAction<unknown, (teamAppId: GuidValue) => void, (result: Process[], teamAppId: GuidValue) => void, (failureReason: any, teamAppId: GuidValue) => void, (teamAppId: GuidValue) => Promise<Process[]>>;
+        copyToNewProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, processStepId: guid) => void, (result: Process, opmProcessId: guid, processStepId: guid) => void, (failureReason: any, opmProcessId: guid, processStepId: guid) => void, (opmProcessId: guid, processStepId: guid) => Promise<Process>>;
+        moveProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, title: string, targetSite: ProcessSite) => void, (result: boolean, opmProcessId: guid, title: string, targetSite: ProcessSite) => void, (failureReason: any, opmProcessId: guid, title: string, targetSite: ProcessSite) => void, (opmProcessId: guid, title: string, targetSite: ProcessSite) => Promise<boolean>>;
+        ensureLoadDraftProcesses: import("@omnia/fx/stores").StoreAction<unknown, (teamAppId: guid) => void, (result: Process[], teamAppId: guid) => void, (failureReason: any, teamAppId: guid) => void, (teamAppId: guid) => Promise<Process[]>>;
         ensureLoadPublishedProcesses: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: Process[]) => void, (failureReason: any) => void, () => Promise<Process[]>>;
-        setNewChangeCommentDraftProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: GuidValue, comment: string) => void, (result: void, opmProcessId: GuidValue, comment: string) => void, (failureReason: any, opmProcessId: GuidValue, comment: string) => void, (opmProcessId: GuidValue, comment: string) => Promise<void>>;
+        setNewChangeCommentDraftProcess: import("@omnia/fx/stores").StoreAction<unknown, (opmProcessId: guid, comment: string) => void, (result: unknown, opmProcessId: guid, comment: string) => void, (failureReason: any, opmProcessId: guid, comment: string) => void, (opmProcessId: guid, comment: string) => Promise<unknown>>;
     };
     private updateProcessState;
     private internalMutations;

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

@@ -1,5 +1,5 @@
 import { Store } from "@omnia/fx/stores";
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { ProcessTemplate } from "../models";
 export declare class ProcessTemplateStore extends Store {
     private processTemplateSerivice;
@@ -11,7 +11,7 @@ export declare class ProcessTemplateStore extends Store {
     private privateMutations;
     actions: {
         ensureLoadProcessTemplates: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
-        ensureLoadProcessTemplate: import("@omnia/fx/stores").StoreAction<unknown, (processTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (result: ProcessTemplate, processTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (failureReason: any, processTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (processTemplateId: GuidValue, alwaysGetLatest?: boolean) => Promise<ProcessTemplate>>;
+        ensureLoadProcessTemplate: import("@omnia/fx/stores").StoreAction<unknown, (processTemplateId: guid, alwaysGetLatest?: boolean) => void, (result: ProcessTemplate, processTemplateId: guid, alwaysGetLatest?: boolean) => void, (failureReason: any, processTemplateId: guid, alwaysGetLatest?: boolean) => void, (processTemplateId: guid, alwaysGetLatest?: boolean) => Promise<ProcessTemplate>>;
         addOrUpdateProcessTemplate: import("@omnia/fx/stores").StoreAction<unknown, (processTemplate: ProcessTemplate) => void, (result: any, processTemplate: ProcessTemplate) => void, (failureReason: any, processTemplate: ProcessTemplate) => void, (processTemplate: ProcessTemplate) => Promise<any>>;
         deleteProcessTemplate: import("@omnia/fx/stores").StoreAction<unknown, (processTemplate: ProcessTemplate) => void, (result: boolean, processTemplate: ProcessTemplate) => void, (failureReason: any, processTemplate: ProcessTemplate) => void, (processTemplate: ProcessTemplate) => Promise<boolean>>;
     };