@omnia/management-system 7.0.4-dev → 7.0.5

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

@@ -1,18 +1,18 @@
-export * from './IColor';
-export * from './NavigationNodeStyles';
-export * from './ProcessStepDrawingStyles';
-export * from './DrawingCanvasSettingsStyles';
-export * from './AddShapePanelStyles';
-export * from './ShapeTypeStyles';
-export * from './DialogStyles';
-export * from './ShapeSelectionStyles';
-export * from './ProcessStepPickerStyles';
-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 "./IColor";
+export * from "./NavigationNodeStyles";
+export * from "./ProcessStepDrawingStyles";
+export * from "./DrawingCanvasSettingsStyles";
+export * from "./AddShapePanelStyles";
+export * from "./ShapeTypeStyles";
+export * from "./DialogStyles";
+export * from "./ShapeSelectionStyles";
+export * from "./ProcessStepPickerStyles";
+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";

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

@@ -1,13 +1,14 @@
-import { FabricShapeData } from '../fabricshape';
-import { ShapeObject } from './ShapeObject';
-import { DrawingShapeDefinition, TooltipCallbacks } from '../../models';
-import { MultilingualString } from '@omnia/fx-models';
+import { FabricShapeData } from "../fabricshape";
+import { ShapeObject } from "./ShapeObject";
+import { DrawingShapeDefinition, TooltipCallbacks } from "../../models";
+import { MultilingualString } from "@omnia/fx-models";
 export declare abstract class Shape implements ShapeObject {
     definition: DrawingShapeDefinition;
     shapeTemplateTypeName: string;
     nodes: FabricShapeData[];
     left: number;
     top: number;
+    angle: number;
     readonly shapeObject: fabric.Object[];
     constructor(definition: DrawingShapeDefinition, nodes?: FabricShapeData[], title?: MultilingualString | string, selectable?: boolean, left?: number, top?: number, darkHighlight?: boolean);
     setAllowHover(allowSetHover: boolean): any;
@@ -25,10 +26,10 @@ export declare abstract class Shape implements ShapeObject {
     };
 }
 interface ShapeClasses<T> {
-    new (definition: DrawingShapeDefinition, nodes?: FabricShapeData[], title?: MultilingualString, selectable?: boolean, left?: number, top?: number, darkHighlight?: boolean): T;
+    new (definition: DrawingShapeDefinition, nodes?: FabricShapeData[], title?: MultilingualString, selectable?: boolean, left?: number, top?: number, angle?: number, darkHighlight?: boolean): T;
 }
 declare class ShapeClassesFactory<T> {
-    createService(ctor: ShapeClasses<T>, definition: DrawingShapeDefinition, nodes?: FabricShapeData[], title?: MultilingualString, selectable?: boolean, left?: number, top?: number, darkHighlight?: boolean): T;
+    createService(ctor: ShapeClasses<T>, definition: DrawingShapeDefinition, nodes?: FabricShapeData[], title?: MultilingualString, selectable?: boolean, left?: number, top?: number, angle?: number, darkHighlight?: boolean): T;
 }
 export declare const ShapeFactory: ShapeClassesFactory<Shape>;
 export {};

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

@@ -1,9 +1,10 @@
-import { FabricShapeData } from '../fabricshape';
-import { DrawingShapeDefinition } from '../../models';
+import { FabricShapeData } from "../fabricshape";
+import { DrawingShapeDefinition } from "../../models";
 export interface ShapeObject {
     shapeTemplateTypeName: string;
     nodes: FabricShapeData[];
     definition: DrawingShapeDefinition;
     left: number;
     top: number;
+    angle: number;
 }

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

@@ -1,5 +1,5 @@
-import { TokenBasedRouter } from '@omnia/fx/ux';
-import { OPMRoute, OPMRouteStateData, Process, ProcessStep } from '../models';
+import { TokenBasedRouter } from "@omnia/fx/ux";
+import { OPMRoute, OPMRouteStateData, Process, ProcessStep } from "../models";
 export declare enum ProcessRendererOptions {
     CurrentRenderer = 0,
     ForceToGlobalRenderer = 1,
@@ -25,12 +25,12 @@ declare class InternalOPMRouter extends TokenBasedRouter<OPMRoute, OPMRouteState
     /**
     * Override protected function logic
     */
-    protected protectedNavigate(title: string, context: OPMRoute, stateData?: OPMRouteStateData): void;
+    protected protectedNavigate(title: string, context: OPMRoute, stateData?: OPMRouteStateData, replaceState?: boolean): void;
     /**
     * Override protected function logic
     */
     protected protectedClearRoute(): void;
-    navigate(process: Process, processStep: ProcessStep, rendererOption?: ProcessRendererOptions): Promise<void>;
+    navigate(process: Process, processStep: ProcessStep, rendererOption?: ProcessRendererOptions, replaceState?: boolean): Promise<void>;
     clearRoute(): void;
     navigateWithCurrentRoute(): Promise<void>;
     private generateOPMRouteData;

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

@@ -1 +1 @@
-export * from './OPMRouter';
+export * from "./OPMRouter";

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

@@ -1,4 +1,4 @@
-import { GuidValue } from '@omnia/fx/models';
+import { GuidValue } from "@omnia/fx/models";
 export declare class ImageService {
     private opmHttpClient;
     constructor();

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

@@ -1,4 +1,4 @@
-import { AuthorAndDefaultReaderUpdateInput } from '../models';
+import { AuthorAndDefaultReaderUpdateInput } from "../models";
 export declare class PermissionService {
     private httpClient;
     constructor();

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

@@ -0,0 +1,11 @@
+import { GuidValue } 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>;
+    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,5 +1,5 @@
-import { GuidValue } from '@omnia/fx/models';
-import { ProcessFeedbackRecipients, ProcessFeedback } from '../models';
+import { GuidValue } from "@omnia/fx/models";
+import { ProcessFeedbackRecipients, ProcessFeedback } from "../models";
 export declare class ProcessFeedbackService {
     private httpClient;
     constructor();

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

@@ -1,4 +1,4 @@
-import { RollupProcessResult, ProcessRollupSetting } from '../models';
+import { RollupProcessResult, ProcessRollupSetting } from "../models";
 export declare class ProcessRollupService {
     private multilingualStore;
     private omniaContext;

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

@@ -1,7 +1,7 @@
-import { GuidValue } from '@omnia/fx/models';
-import { ProcessActionModel, Process, ProcessData, IdDict, ProcessCheckoutInfo, ProcessWithCheckoutInfo, Version } from '../models';
-import { ProcessLibraryStatus, ProcessSite } from '../../models';
-import { ProcessExportData } from '../models/data/processes/ProcessExportData';
+import { GuidValue } 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";
 export declare class ProcessService {
     private multilingualStore;
     private omniaContext;
@@ -10,6 +10,7 @@ export declare class ProcessService {
     checkIfDraftExists: (opmProcessId: string) => Promise<boolean>;
     createDraftProcess: (processActionModel: ProcessActionModel) => Promise<Process>;
     createDraftProcessFromPublished: (opmProcessId: GuidValue) => Promise<Process>;
+    restoreProcess: (processId: GuidValue) => Promise<Process>;
     checkinProcess: (opmProcessId: GuidValue) => Promise<Process>;
     saveCheckedOutProcess: (processActionModel: ProcessActionModel) => Promise<Process>;
     getProcessCheckoutInfo: (opmProcessId: GuidValue) => Promise<ProcessCheckoutInfo>;
@@ -18,14 +19,17 @@ export declare class ProcessService {
     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>;
     unpublishProcess: (opmProcessId: string) => Promise<boolean>;
@@ -33,8 +37,11 @@ export declare class ProcessService {
     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[]>;
     resolveAuthoringSite: (targetUrl: string) => Promise<ProcessSite>;
+    filterDeletedProcesses: (teamAppId: GuidValue) => Promise<Process[]>;
+    getPublishedProcessesAllSystem: () => Promise<Process[]>;
     private generateClientSideData;
     private setProcessStepMultilingualTitle;
 }

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

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

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

@@ -1,5 +1,5 @@
-import { GuidValue } from '@omnia/fx/models';
-import { ProcessTemplate } from '../models';
+import { GuidValue } from "@omnia/fx/models";
+import { ProcessTemplate } from "../models";
 export declare class ProcessTemplateService {
     private multilingualStore;
     private httpClient;

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

@@ -1,5 +1,5 @@
-import { GuidValue } from '@omnia/fx/models';
-import { ProcessType } from '../models';
+import { GuidValue } from "@omnia/fx/models";
+import { ProcessType } from "../models";
 export declare class ProcessTypeService {
     private httpClient;
     constructor();

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

@@ -1,5 +1,5 @@
-import { HttpClient } from '@omnia/fx';
-import { EnterprisePropertyColumnMapping } from '@omnia/fx/models';
+import { HttpClient } from "@omnia/fx";
+import { EnterprisePropertyColumnMapping } from "@omnia/fx/models";
 export declare class QueryablePropertiesService {
     protected httpClient: HttpClient;
     baseUrl: string;

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

@@ -1,4 +1,4 @@
-import { Setting } from '../models';
+import { Setting } from "../models";
 export declare class SettingsService {
     private httpClient;
     constructor();

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

@@ -1,5 +1,5 @@
-import { GuidValue } from '@omnia/fx/models';
-import { ShapeTemplate } from '../models';
+import { GuidValue } from "@omnia/fx/models";
+import { ShapeTemplate } from "../models";
 export declare class ShapeTemplateService {
     private multilingualStore;
     private httpClient;

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

@@ -1,4 +1,4 @@
-import { TaskRequest, CSOMSharePointTaskResponse } from '../models';
+import { TaskRequest, CSOMSharePointTaskResponse } from "../models";
 export declare class SharePointTaskService {
     private httpClient;
     private emptyHttpClient;

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

@@ -1,5 +1,5 @@
-import { OmniaContext } from '@omnia/fx';
-import { ProcessPropertyInfo } from '../models';
+import { OmniaContext } from "@omnia/fx";
+import { ProcessPropertyInfo } from "../models";
 export declare class TeamAppPropertyService {
     private httpClient;
     omniaContext: OmniaContext;

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

@@ -1,13 +1,15 @@
-export * from './ProcessTemplateService';
-export * from './ProcessService';
-export * from './ProcessTypeService';
-export * from './SettingsService';
-export * from './PermissionService';
-export * from './SharePointTaskService';
-export * from './ImageService';
-export * from './ProcessRollupService';
-export * from './ShapeTemplateService';
-export * from './TeamAppPropertyService';
-export * from './MoveProcessService';
-export * from './ProcessFeedbackService';
-export * from './QueryablePropertiesService';
+export * from "./ProcessTemplateService";
+export * from "./ProcessService";
+export * from "./ProcessTypeService";
+export * from "./SettingsService";
+export * from "./PermissionService";
+export * from "./SharePointTaskService";
+export * from "./ImageService";
+export * from "./ProcessRollupService";
+export * from "./ProcessDocumentRelationshipService";
+export * from "./ShapeTemplateService";
+export * from "./TeamAppPropertyService";
+export * from "./MoveProcessService";
+export * from "./ProcessFeedbackService";
+export * from "./QueryablePropertiesService";
+export * from "./ProcessTaskService";

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

@@ -1,5 +1,5 @@
-import { ISettingsKeyProvider } from '@omnia/fx/services';
-import { DocumentRollupBlockSettings } from '../models';
+import { ISettingsKeyProvider } from "@omnia/fx/services";
+import { DocumentRollupBlockSettings } from "../models";
 export declare class DocumentRollupSettingsProvider implements ISettingsKeyProvider {
     private onChanged?;
     private currentProcessStore;

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

@@ -1,4 +1,4 @@
-import { ISettingsKeyProvider } from '@omnia/fx/services';
+import { ISettingsKeyProvider } from "@omnia/fx/services";
 import { PageRollupBlockSettings } from "@omnia/wcm/models";
 export declare class PageRollupSettingsProvider implements ISettingsKeyProvider {
     private onChanged?;

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

@@ -1,2 +1,2 @@
-export * from './DocumentRollupSettingsProvider';
-export * from './PageRollupSettingsProvider';
+export * from "./DocumentRollupSettingsProvider";
+export * from "./PageRollupSettingsProvider";

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

@@ -1,33 +1,41 @@
 /// <reference types="node" />
-import { Store } from '@omnia/fx/stores';
-import { PermissionService } from '@omnia/fx/services';
-import { GuidValue, MultilingualString } from '@omnia/fx-models';
-import { ProcessReference, ProcessReferenceData, Process, IdDict, InternalProcessStep, ExternalProcessStep, Version } from '../models';
+import { Store } from "@omnia/fx/stores";
+import { PermissionService } from "@omnia/fx/services";
+import { GuidValue, 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 {
     permissionService: PermissionService;
     private processStore;
     private multilingualStore;
     private currentProcessReference;
     private currentProcessReferenceData;
+    private currentProcessTemplateLayout;
+    private isPreviewingProcess;
     private relevantProcessStepIdAndProcessIdDict;
     private relevantProcessIdAndProcessStepIdDictDict;
     private currentLoadedProcessDataDict;
     private currentProcessJson;
     private currentLoadedProcessDataJsonDict;
     private transaction;
-    constructor();
     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) => {
             process: Process;
             processStepIdDict: IdDict<boolean>;
         };
+        basedLayoutProcessStep: () => InternalProcessStep;
+        processTemplateLayout: () => Layout;
+    };
+    mutations: {
+        setIsPreviewingProcess: import("@omnia/fx/stores").StoreMutation<(isPreviewing: boolean) => void, (isPreviewing: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
-    mutations: {};
     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>>;
         checkOut: import("@omnia/fx/stores").StoreAction<unknown, (takeControl?: boolean) => void, (result: null, takeControl?: boolean) => void, (failureReason: any, takeControl?: boolean) => void, (takeControl?: boolean) => Promise<null>>;
@@ -53,6 +61,7 @@ export declare class CurrentProcessStore extends Store {
     private getRelevantProcess;
     private updateProcessStepIdAndProcessIdDict;
     private prepareProcessReferenceToUse;
+    private ensureProcessDataLayout;
     protected onActivated(): void;
     protected onDisposing(): void;
 }

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

@@ -1,9 +1,10 @@
-import { Store } from '@omnia/fx/stores';
-import { GuidValue, MediaPickerImage } from '@omnia/fx-models';
-import { MoveProcessService } from '../services';
-import { ProcessActionModel, Process, ProcessReference, ProcessReferenceData, ProcessCheckoutInfo, ProcessWithCheckoutInfo, Version, ProcessMoveInfo } from '../models';
-import { ProcessSite } from '../../models';
+import { Store } from "@omnia/fx/stores";
+import { GuidValue, 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;
 }
@@ -15,21 +16,25 @@ interface NotificationMessage {
 }
 export declare class ProcessStore extends Store {
     private processService;
-    private omniaContext;
     moveProcessService: MoveProcessService;
     mediaPickerService: MediaPickerService;
+    processTemplateLayoutStore: ProcessTemplateLayoutStore;
     private processDict;
     private processCheckoutInfoDict;
     private processDataDict;
     private processSiteDict;
     private processMoveSiteInfoDict;
+    private processDataLayoutMergeResultDict;
+    private processTemplateLayoutDict;
+    private processes;
+    private publishedProcesses;
+    private draftProcesses;
     private processLoadPromises;
     private processDataLoadPromises;
     private processSiteLoadPromises;
     private processStepIdAndProcessIdDict;
     notificationMessage: import("@omnia/fx/stores").StoreState<NotificationMessage>;
     readonly moveMessageTimeout = 10000;
-    constructor();
     getters: {
         getProcessReferenceData: (processReference: ProcessReference) => ProcessReferenceData;
         processCheckoutInfo: (opmProcessId: GuidValue) => ProcessCheckoutInfo;
@@ -38,6 +43,9 @@ export declare class ProcessStore extends Store {
         processMoveSiteInfo: (opmProcessId: GuidValue) => ProcessMoveInfo;
         processMoveSiteInfoDict: () => ProcessMoveInfoDict;
         getImageUrl: (image: MediaPickerImage, imageUrl?: string) => string;
+        getAllDraftPublishedProcesses: () => Array<Process>;
+        getDraftProcesses: (teamAppId: GuidValue) => Process[];
+        getPublishedProcesses: () => Process[];
     };
     mutations: {
         removeProcessMoveSiteInfoDict: import("@omnia/fx/stores").StoreMutation<(removeDict: ProcessMoveInfoDict) => void, (removeDict: ProcessMoveInfoDict) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
@@ -45,18 +53,23 @@ export declare class ProcessStore extends Store {
     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) => void, (result: Process, opmProcessId: GuidValue) => void, (failureReason: any, opmProcessId: GuidValue) => void, (opmProcessId: GuidValue) => 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>>;
         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>>;
         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>>;
         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[]>>;
+        ensureLoadPublishedProcesses: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: Process[]) => void, (failureReason: any) => void, () => Promise<Process[]>>;
     };
     private internalMutations;
     private ensureProcess;
@@ -70,6 +83,8 @@ export declare class ProcessStore extends Store {
     private getProcessCacheKey;
     private getProcessSiteCacheKey;
     private getProcessDataCacheKey;
+    private getProcessDataLayoutMergedResultCacheKey;
+    private getProcessTemplateLayoutCacheKey;
     protected onActivated(): void;
     protected onDisposing(): void;
 }

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

@@ -0,0 +1,18 @@
+import { IVersionedDataIdentifier, VersionedLayout } from "@omnia/fx/models";
+import { Store, VersionedLayoutStore } from "@omnia/fx/stores";
+import { ProcessTemplateLayoutDefinition } from "../models";
+export declare class ProcessTemplateLayoutStore extends Store {
+    versionedLayoutStore: VersionedLayoutStore;
+    private processTemplateLayouts;
+    private ensureLoadProcessTemplateLayoutsPromise;
+    getters: {
+        processTemplateLayouts: () => VersionedLayout[];
+    };
+    actions: {
+        ensureLoadProcessTemplateLayouts: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: VersionedLayout[]) => void, (failureReason: any) => void, () => Promise<VersionedLayout[]>>;
+        ensureLoadProcessTemplateLayoutDefinitionByLayout: import("@omnia/fx/stores").StoreAction<unknown, (layout: VersionedLayout) => void, (result: ProcessTemplateLayoutDefinition, layout: VersionedLayout) => void, (failureReason: any, layout: VersionedLayout) => void, (layout: VersionedLayout) => Promise<ProcessTemplateLayoutDefinition>>;
+        ensureLoadProcessTemplateLayoutDefinition: import("@omnia/fx/stores").StoreAction<unknown, (versionedDataIdentifier: IVersionedDataIdentifier) => void, (result: ProcessTemplateLayoutDefinition, versionedDataIdentifier: IVersionedDataIdentifier) => void, (failureReason: any, versionedDataIdentifier: IVersionedDataIdentifier) => void, (versionedDataIdentifier: IVersionedDataIdentifier) => Promise<ProcessTemplateLayoutDefinition>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -1,11 +1,10 @@
-import { Store } from '@omnia/fx/stores';
-import { GuidValue } from '@omnia/fx-models';
-import { ProcessTemplate } from '../models';
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { ProcessTemplate } from "../models";
 export declare class ProcessTemplateStore extends Store {
     private processTemplateSerivice;
     private processTemplates;
     private ensureLoadProcessTemplatesPromise;
-    constructor();
     getters: {
         processTemplates: () => ProcessTemplate[];
     };

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

@@ -1,6 +1,6 @@
-import { Store } from '@omnia/fx/stores';
-import { GuidValue } from '@omnia/fx-models';
-import { ProcessType } from '../models';
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { ProcessType } from "../models";
 export declare class ProcessTypeStore extends Store {
     private processTypeService;
     private termStore;
@@ -14,7 +14,6 @@ export declare class ProcessTypeStore extends Store {
     private processTypes;
     private processTypesDict;
     private allProcessTypeItems;
-    constructor();
     getters: {
         all: () => Array<ProcessType>;
         children: (parentId?: GuidValue, includeInvalid?: boolean) => Array<ProcessType>;

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

@@ -1,10 +1,9 @@
-import { Store } from '@omnia/fx/stores';
-import { Setting, DynamicKeySetting } from '../models';
+import { Store } from "@omnia/fx/stores";
+import { Setting, DynamicKeySetting } from "../models";
 export declare class SettingsStore extends Store {
     private settingsService;
     private ensureSettingsPromises;
     private settings;
-    constructor();
     getters: {
         getByModel: <T extends Setting>(model: new () => T) => T;
         getByDynamicKeyModel: <T_1 extends DynamicKeySetting>(model: new (dynamicKey: string) => T_1, dynamicKey: string) => T_1;

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

@@ -1,11 +1,10 @@
-import { Store } from '@omnia/fx/stores';
-import { GuidValue } from '@omnia/fx-models';
-import { ShapeTemplate } from '../models';
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } from "@omnia/fx-models";
+import { ShapeTemplate } from "../models";
 export declare class ShapeTemplateStore extends Store {
     private shapeTemplateService;
     private shapeTemplates;
     private ensureLoadShapeTemplatesPromise;
-    constructor();
     getters: {
         shapeTemplates: () => ShapeTemplate[];
     };

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

@@ -1,6 +1,7 @@
-export * from './ProcessTemplateStore';
-export * from './ProcessStore';
-export * from './CurrentProcessStore';
-export * from './ProcessTypeStore';
-export * from './SettingsStore';
-export * from './ShapeTemplateStore';
+export * from "./ProcessTemplateStore";
+export * from "./ProcessStore";
+export * from "./CurrentProcessStore";
+export * from "./ProcessTypeStore";
+export * from "./SettingsStore";
+export * from "./ShapeTemplateStore";
+export * from "./ProcessTemplateLayoutStore";