@omnia/management-system 7.0.4 → 7.0.5

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

@@ -0,0 +1,12 @@
+import { GuidValue } 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>;
+    addOrUpdateShapeTemplateItem: (shapeTemplate: ShapeTemplate) => Promise<ShapeTemplate>;
+    deleteShapeTemplate: (id: GuidValue) => Promise<void>;
+    private generateShapeTemplatesMultilingualText;
+}

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

@@ -0,0 +1,7 @@
+import { TaskRequest, CSOMSharePointTaskResponse } from "../models";
+export declare class SharePointTaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getTasks: (request: TaskRequest) => Promise<CSOMSharePointTaskResponse>;
+}

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

@@ -0,0 +1,8 @@
+import { OmniaContext } from "@omnia/fx";
+import { ProcessPropertyInfo } from "../models";
+export declare class TeamAppPropertyService {
+    private httpClient;
+    omniaContext: OmniaContext;
+    constructor();
+    getTeamAppProperties: () => Promise<Array<ProcessPropertyInfo>>;
+}

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

@@ -0,0 +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 "./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

@@ -0,0 +1,13 @@
+import { ISettingsKeyProvider } from "@omnia/fx/services";
+import { DocumentRollupBlockSettings } from "../models";
+export declare class DocumentRollupSettingsProvider implements ISettingsKeyProvider {
+    private onChanged?;
+    private currentProcessStore;
+    constructor(onChanged?: (key: string, value: DocumentRollupBlockSettings, isUpdate: boolean) => void);
+    protectKeyWithSecurityRole: (securityRoleId: string) => void;
+    private initDefaultBlockData;
+    getValue: (key: string) => Promise<DocumentRollupBlockSettings>;
+    canSetValue: (key: string) => Promise<boolean>;
+    setValue: (key: string, value: DocumentRollupBlockSettings) => Promise<any>;
+    private getProcessReference;
+}

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

@@ -0,0 +1,13 @@
+import { ISettingsKeyProvider } from "@omnia/fx/services";
+import { PageRollupBlockSettings } from "@omnia/wcm/models";
+export declare class PageRollupSettingsProvider implements ISettingsKeyProvider {
+    private onChanged?;
+    private currentProcessStore;
+    constructor(onChanged?: (key: string, value: PageRollupBlockSettings, isUpdate: boolean) => void);
+    protectKeyWithSecurityRole: (securityRoleId: string) => void;
+    private initDefaultBlockData;
+    getValue: (key: string) => Promise<PageRollupBlockSettings>;
+    canSetValue: (key: string) => Promise<boolean>;
+    setValue: (key: string, value: PageRollupBlockSettings) => Promise<any>;
+    private getProcessReference;
+}

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

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

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

@@ -0,0 +1,67 @@
+/// <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 { 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;
+    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>;
+    };
+    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>>;
+        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>>;
+        addProcessStep: import("@omnia/fx/stores").StoreAction<unknown, (title: MultilingualString) => void, (result: {
+            process: Process;
+            processStep: InternalProcessStep;
+        }, title: MultilingualString) => void, (failureReason: any, title: MultilingualString) => void, (title: MultilingualString) => Promise<{
+            process: Process;
+            processStep: InternalProcessStep;
+        }>>;
+        addExtenalProcessStep: import("@omnia/fx/stores").StoreAction<unknown, (title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (result: {
+            process: Process;
+            processStep: ExternalProcessStep;
+        }, title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (failureReason: any, title: MultilingualString, externalRootProcessStepId: GuidValue) => void, (title: MultilingualString, externalRootProcessStepId: GuidValue) => Promise<{
+            process: Process;
+            processStep: ExternalProcessStep;
+        }>>;
+        saveState: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        discardChange: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+    };
+    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

@@ -0,0 +1,91 @@
+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;
+}
+interface NotificationMessage {
+    message: string;
+    show: boolean;
+    timeout: number;
+    customRenderer: string;
+}
+export declare class ProcessStore extends Store {
+    private processService;
+    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;
+    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;
+        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>;
+    };
+    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;
+    private ensureProcessSite;
+    private ensureProcessData;
+    private getProcessLoadResolvablePromise;
+    private getProcessSiteLoadResolvablePromise;
+    private getProcessDataLoadResolvablePromise;
+    private getProcessCheckoutCacheKey;
+    private getProcessMoveCacheKey;
+    private getProcessCacheKey;
+    private getProcessSiteCacheKey;
+    private getProcessDataCacheKey;
+    private getProcessDataLayoutMergedResultCacheKey;
+    private getProcessTemplateLayoutCacheKey;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+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;
+    getters: {
+        processTemplates: () => ProcessTemplate[];
+    };
+    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>>;
+        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>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,41 @@
+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;
+    private multilingualTextsStore;
+    private ensuredChildrenPromises;
+    private ensuredProcessTypePromises;
+    private refreshCachePromises;
+    private ensureRootProcessTypePromise;
+    private ensureLoadProcessTypesPromise;
+    private processTypeTermSetId;
+    private processTypes;
+    private processTypesDict;
+    private allProcessTypeItems;
+    getters: {
+        all: () => Array<ProcessType>;
+        children: (parentId?: GuidValue, includeInvalid?: boolean) => Array<ProcessType>;
+        byId: (id: GuidValue, includeInvalid?: boolean) => ProcessType;
+        rootProcessTypeInGlobalSettings: () => ProcessType;
+    };
+    private isValidProcessType;
+    private privateMutations;
+    private sortByChildrenOrders;
+    private ensureChildren;
+    actions: {
+        ensureRootProcessType: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureChildren: import("@omnia/fx/stores").StoreAction<unknown, (parentId?: GuidValue) => void, (result: null, parentId?: GuidValue) => void, (failureReason: any, parentId?: GuidValue) => void, (parentId?: GuidValue) => Promise<null>>;
+        createProcessType: import("@omnia/fx/stores").StoreAction<unknown, (processType: ProcessType) => void, (result: ProcessType, processType: ProcessType) => void, (failureReason: any, processType: ProcessType) => void, (processType: ProcessType) => Promise<ProcessType>>;
+        updateProcessType: import("@omnia/fx/stores").StoreAction<unknown, (processType: ProcessType) => void, (result: ProcessType, processType: ProcessType) => void, (failureReason: any, processType: ProcessType) => void, (processType: ProcessType) => Promise<ProcessType>>;
+        removeProcessType: import("@omnia/fx/stores").StoreAction<unknown, (processType: ProcessType) => void, (result: any, processType: ProcessType) => void, (failureReason: any, processType: ProcessType) => void, (processType: ProcessType) => Promise<any>>;
+        ensureProcessTypes: import("@omnia/fx/stores").StoreAction<unknown, (processTypeIds: GuidValue[]) => void, (result: any, processTypeIds: GuidValue[]) => void, (failureReason: any, processTypeIds: GuidValue[]) => void, (processTypeIds: Array<GuidValue>) => Promise<any>>;
+        refreshCache: import("@omnia/fx/stores").StoreAction<unknown, (trackingNumber: number) => void, (result: null, trackingNumber: number) => void, (failureReason: any, trackingNumber: number) => void, (trackingNumber: number) => Promise<null>>;
+        ensureLoadProcessTypes: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+    };
+    private isRootParentId;
+    private getParentId;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

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

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

@@ -0,0 +1,20 @@
+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;
+    getters: {
+        shapeTemplates: () => ShapeTemplate[];
+    };
+    private privateMutations;
+    actions: {
+        ensureLoadShapeTemplates: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureLoadShapeTemplate: import("@omnia/fx/stores").StoreAction<unknown, (shapeTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (result: ShapeTemplate, shapeTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (failureReason: any, shapeTemplateId: GuidValue, alwaysGetLatest?: boolean) => void, (shapeTemplateId: GuidValue, alwaysGetLatest?: boolean) => Promise<ShapeTemplate>>;
+        addOrUpdateShapeTemplate: import("@omnia/fx/stores").StoreAction<unknown, (shapeTemplate: ShapeTemplate) => void, (result: ShapeTemplate, shapeTemplate: ShapeTemplate) => void, (failureReason: any, shapeTemplate: ShapeTemplate) => void, (shapeTemplate: ShapeTemplate) => Promise<ShapeTemplate>>;
+        deleteShapeGalleryItem: import("@omnia/fx/stores").StoreAction<unknown, (shapeTemplate: ShapeTemplate) => void, (result: any, shapeTemplate: ShapeTemplate) => void, (failureReason: any, shapeTemplate: ShapeTemplate) => void, (shapeTemplate: ShapeTemplate) => Promise<any>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

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

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

@@ -0,0 +1,29 @@
+import { ProcessStep, Process, ProcessReference, RootProcessStep, InternalProcessStep, DrawingShapeDefinition } from "../fx/models";
+import { GuidValue } from "@omnia/fx-models";
+import { MultilingualStore } from "@omnia/fx/stores";
+import { MultilingualString } from "@omnia/fx/models";
+export declare module OPMUtils {
+    function generateProcessStepExpandState(processStep: RootProcessStep, processStepId: GuidValue): {
+        [processStepId: string]: true;
+    };
+    function getProcessStepInProcess(processStep: RootProcessStep, desiredProcessStepId: GuidValue): {
+        desiredProcessStep: ProcessStep;
+        parentProcessSteps: Array<InternalProcessStep>;
+    };
+    function generateProcessReference(process: Process, processStepId: GuidValue): ProcessReference;
+    function getAllProcessStepIds(processStep: ProcessStep): string[];
+    function getUserPrincipleName(loginName: string): string;
+    function createProcessNavigationUrl(process: Process, desiredProcessStep: ProcessStep, previewPageUrl: string, omniaApp: boolean, previewInDesingerIframe?: boolean): string;
+    function getProcessPreviewUrl(processStepId: string, omniaUrl: string, isIframe: boolean): string;
+    function isOPMPreviewMode(): boolean;
+    function isDraftExistsErrMsg(errMsg: string): boolean;
+    function isCheckedOutNotExistsErrMsg(errMsg: string): boolean;
+    function isCheckedOutByOtherErrMsg(errMsg: string): boolean;
+    function isProcessNotFound(errMsg: string): boolean;
+    function waitForElementAvailable(el: Element, elementId: string, callBack: () => void, msToCheck?: number): void;
+    function getTextString(multilingualStore: MultilingualStore, definition: DrawingShapeDefinition, title: string | MultilingualString): string;
+    function openCustomLink(url: string, openNewWindow: boolean): void;
+    function parentFrameIsMsTeams(): boolean;
+    function IsOpenEditorPreview(): boolean;
+    function buildContextIdentifier(appId: GuidValue, processRoute: string): string;
+}

package/internal-do-not-import-from-here/ux/filterengine/ProcessFilterEngine.manifest.d.ts

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

package/internal-do-not-import-from-here/ux/filterengine/api/Api.manifest.d.ts

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

package/internal-do-not-import-from-here/ux/filterengine/api/ProcessRegistration.d.ts

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

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

@@ -0,0 +1,15 @@
+import ProcessFilterEngineHandler from "../../../handler/ProcessFilterEngineHandler";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    typedHandler: ProcessFilterEngineHandler;
+}, "typedHandler">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        typedHandler: ProcessFilterEngineHandler;
+    }, "typedHandler">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    typedHandler: ProcessFilterEngineHandler;
+}, "typedHandler">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        typedHandler: ProcessFilterEngineHandler;
+    }, "typedHandler">;
+});
+export default _default;

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

@@ -0,0 +1,4 @@
+import { types } from "typestyle";
+export declare const ProcessPropertyRendererStyle: {
+    selectedStyle: (selected: boolean) => types.NestedCSSProperties;
+};

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

@@ -0,0 +1,19 @@
+import ProcessFilterEngineHandler from "../../../handler/ProcessFilterEngineHandler";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    typedHandler: ProcessFilterEngineHandler;
+    visibleSelectionsCount: number;
+}, "typedHandler">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        typedHandler: ProcessFilterEngineHandler;
+        visibleSelectionsCount: number;
+    }, "typedHandler">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    typedHandler: ProcessFilterEngineHandler;
+    visibleSelectionsCount: number;
+}, "typedHandler">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        typedHandler: ProcessFilterEngineHandler;
+        visibleSelectionsCount: number;
+    }, "typedHandler">;
+});
+export default _default;

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

@@ -0,0 +1,32 @@
+import { EnterprisePropertyDefinition } from "@omnia/fx/models";
+import { ProcessFilterEngineProperty } from "../../../../../models/filterengine/Shared";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    property: ProcessFilterEngineProperty;
+    updateData: () => void;
+    propertyDefinitionAsHash: {
+        [internalName: string]: EnterprisePropertyDefinition;
+    };
+}, "property" | "updateData" | "propertyDefinitionAsHash">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        property: ProcessFilterEngineProperty;
+        updateData: () => void;
+        propertyDefinitionAsHash: {
+            [internalName: string]: EnterprisePropertyDefinition;
+        };
+    }, "property" | "updateData" | "propertyDefinitionAsHash">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    property: ProcessFilterEngineProperty;
+    updateData: () => void;
+    propertyDefinitionAsHash: {
+        [internalName: string]: EnterprisePropertyDefinition;
+    };
+}, "property" | "updateData" | "propertyDefinitionAsHash">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        property: ProcessFilterEngineProperty;
+        updateData: () => void;
+        propertyDefinitionAsHash: {
+            [internalName: string]: EnterprisePropertyDefinition;
+        };
+    }, "property" | "updateData" | "propertyDefinitionAsHash">;
+});
+export default _default;

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

@@ -0,0 +1,36 @@
+import { EnterprisePropertyDefinition, FilterEngineContext } from "@omnia/fx-models";
+import { ProcessFilterEngineProperty } from "../../../../../models/filterengine/Shared";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    property: ProcessFilterEngineProperty;
+    updateData: () => void;
+    propertyDefinitionAsHash: {
+        [internalName: string]: EnterprisePropertyDefinition;
+    };
+    context: FilterEngineContext;
+}, "context" | "updateData">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        property: ProcessFilterEngineProperty;
+        updateData: () => void;
+        propertyDefinitionAsHash: {
+            [internalName: string]: EnterprisePropertyDefinition;
+        };
+        context: FilterEngineContext;
+    }, "context" | "updateData">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    property: ProcessFilterEngineProperty;
+    updateData: () => void;
+    propertyDefinitionAsHash: {
+        [internalName: string]: EnterprisePropertyDefinition;
+    };
+    context: FilterEngineContext;
+}, "context" | "updateData">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        property: ProcessFilterEngineProperty;
+        updateData: () => void;
+        propertyDefinitionAsHash: {
+            [internalName: string]: EnterprisePropertyDefinition;
+        };
+        context: FilterEngineContext;
+    }, "context" | "updateData">;
+});
+export default _default;

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

@@ -0,0 +1,3 @@
+import { FilterEngineContext } from "@omnia/fx-models";
+import { ProcessFilterEngineProperty } from "../../../../../models/filterengine/Shared";
+export default function ensureValidProcessSettings(context: FilterEngineContext, propertySettings: ProcessFilterEngineProperty): void;

package/internal-do-not-import-from-here/ux/filterengine/handler/ProcessFilterEngineHandler.d.ts

@@ -0,0 +1,28 @@
+import { BaseFilterEnginePropertyOutput, EnterprisePropertyDefinition, GuidValue, ITypedFilterEngineHandler, QueryFilterEnginePropertyOutput, Refinement, Refiner, TextFilterEnginePropertyOutput } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { ProcessFilterEngineProperty } from "../../../models/filterengine/Shared";
+export default class ProcessFilterEngineHandler extends Store implements ITypedFilterEngineHandler {
+    readonly propertyDefinition: EnterprisePropertyDefinition;
+    readonly property: ProcessFilterEngineProperty;
+    showContentOnly: boolean;
+    private mediator;
+    /**
+     *
+     */
+    constructor(property: ProcessFilterEngineProperty, propertyOutput: QueryFilterEnginePropertyOutput, isRefinable: boolean, hasFilterState: boolean, enterpriseProperty: EnterprisePropertyDefinition);
+    generateTypedPropertyOutput: () => TextFilterEnginePropertyOutput;
+    generatePropertyOutput: () => BaseFilterEnginePropertyOutput;
+    clearAllSelections: () => void;
+    needAdditionalRefinementQuery(): boolean;
+    setLatestRefiner(refiner: Refiner<Refinement>): void;
+    subscribeChange: () => (fn: (obj: void) => void) => import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    resolveData: () => Promise<void>;
+    actions: {
+        setFilterPropertyValue: import("@omnia/fx/stores").StoreAction<unknown, (newValue: GuidValue[]) => void, (result: void, newValue: GuidValue[]) => void, (failureReason: any, newValue: GuidValue[]) => void, (newValue: Array<GuidValue>) => Promise<void>>;
+    };
+    init(): Promise<void>;
+    isRefinable(): boolean;
+    getSelectionCount(): number;
+    onActivated: () => void;
+    onDisposing: () => void;
+}

package/package.json

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

package/task.d.ts

@@ -0,0 +1 @@
+export declare function init(): void;

package/task.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const tooling_vue_1 = require("@omnia/tooling-vue");
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const fsExtra = require("fs-extra");
+function init() {
+    (0, tooling_vue_1.registerManifestsReference)([
+        {
+            path: "node_modules/@omnia/management-system/internal-do-not-import-from-here/manifests/omnia.ms.fx.manifest.json",
+            serviceId: "b3d13ef7-5ff8-4496-a283-81a742080aef",
+            resourceId: "54a125ba-c2f8-4c4c-b549-ce0c3861026b"
+        }
+    ]);
+    const wcdefinitionsPath = path.resolve(__dirname, "./internal-do-not-import-from-here/wcdefinitions.json");
+    if (fsExtra.existsSync(wcdefinitionsPath)) {
+        (0, tooling_vue_1.registerWebComponentDefinitions)(fsExtra.readJSONSync(wcdefinitionsPath));
+    }
+}
+exports.init = init;