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

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

@@ -0,0 +1,17 @@
+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: 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>;
+    previewPublishedDocument: (request: PreviewPublishedDocumentRequest) => Promise<void>;
+    getReadReceiptSignOffByOdmDocId: (odmDocId: string, webUrl: string) => Promise<DocumentNotifiedPerson>;
+    getReadReceiptHistory: (odmDocId: string, webUrl: string) => Promise<Array<DocumentReadReceiptsHistory>>;
+    setReadReceiptSignOffStatus: (id: guid, isReadAndUnderstood: boolean) => Promise<void>;
+    setMovingToTargetSiteDocumentStatus: (sqlDocumentId: string, odmDocumentId: string, currentSiteUrl: string, targetSiteUrl: string) => Promise<Enums.DocumentViewEnums.LibraryDocumentStatus>;
+    movePageToTargetSite: (moveDocumentRequest: MoveDocumentToTargetSiteRequest) => Promise<void>;
+    getPublishedDocumentByOdmDocId: (odmDocId: string, webUrl: string) => Promise<ControlledDocument>;
+}

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

@@ -0,0 +1,5 @@
+import { CompleteReviewReminderTaskRequest } from "../../models";
+export declare class ReviewReminderTaskService {
+    private httpClient;
+    completeReviewReminderTask: (request: CompleteReviewReminderTaskRequest) => Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import { Workflow, ReviewTaskParams, ReviewTask, SqlDocument, SharePointUser, WorkflowTask } from "../../models";
+export declare class ReviewTaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getReviewTaskById: (itemId: number, webUrl: string) => Promise<ReviewTask>;
+    completeReviewTask: (request: ReviewTaskParams) => Promise<string>;
+    processCompletingReviewTask: (task: ReviewTask) => Promise<void>;
+    getFileLockedByUserWhenTaskIsLastIncompleted: (task: ReviewTask) => Promise<SharePointUser>;
+    sendDocumentToReview: (params: ReviewTaskParams) => Promise<SqlDocument>;
+    processSendingDocumentToReview: (params: ReviewTaskParams) => Promise<void>;
+    addNewReviewer: (params: ReviewTaskParams) => Promise<WorkflowTask[]>;
+    forwardToReviewer: (params: ReviewTaskParams) => Promise<string>;
+    cancelReviewWorkflow: (documentReview: Workflow, spId: number, webUrl: string) => Promise<void>;
+    processCancellingReviewWorkflow: (documentReview: Workflow) => Promise<void>;
+    removeReviewTask: (task: ReviewTask) => Promise<boolean>;
+}

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

@@ -0,0 +1,11 @@
+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: guid, webUrl: string, 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

@@ -0,0 +1,6 @@
+export * from "./TaskService";
+export * from "./DocumentLibraryService";
+export * from "./ReviewTaskService";
+export * from "./PublishDocumentService";
+export * from "./ReviewReminderTaskService";
+export * from "./ApprovalTaskService";

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

@@ -13,3 +13,6 @@ export * from "./MoveProcessService";
 export * from "./ProcessFeedbackService";
 export * from "./QueryablePropertiesService";
 export * from "./ProcessTaskService";
+export * from "./documentlibrary";
+export * from "./document";
+export * from "./UserService";

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

@@ -1,8 +1,6 @@
-/// <reference types="node" />
-/// <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 {
@@ -22,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>;
         };
@@ -37,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>>;
@@ -49,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,5 +1,5 @@
 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";
@@ -37,40 +37,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>>;
     };

package/internal-do-not-import-from-here/stores/ProcessTypeStore.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 { ProcessType } from "../models";
 export declare class ProcessTypeStore extends Store {
     private processTypeService;
@@ -16,8 +16,8 @@ export declare class ProcessTypeStore extends Store {
     private allProcessTypeItems;
     getters: {
         all: () => Array<ProcessType>;
-        children: (parentId?: GuidValue, includeInvalid?: boolean) => Array<ProcessType>;
-        byId: (id: GuidValue, includeInvalid?: boolean) => ProcessType;
+        children: (parentId?: guid, includeInvalid?: boolean) => Array<ProcessType>;
+        byId: (id: guid, includeInvalid?: boolean) => ProcessType;
         rootProcessTypeInGlobalSettings: () => ProcessType;
     };
     private isValidProcessType;
@@ -26,11 +26,11 @@ export declare class ProcessTypeStore extends Store {
     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>>;
+        ensureChildren: import("@omnia/fx/stores").StoreAction<unknown, (parentId?: guid) => void, (result: null, parentId?: guid) => void, (failureReason: any, parentId?: guid) => void, (parentId?: guid) => 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>>;
+        ensureProcessTypes: import("@omnia/fx/stores").StoreAction<unknown, (processTypeIds: guid[]) => void, (result: any, processTypeIds: guid[]) => void, (failureReason: any, processTypeIds: guid[]) => void, (processTypeIds: Array<guid>) => Promise<any>>;
         refreshCache: import("@omnia/fx/stores").StoreAction<unknown, (trackingNumber: number) => void, (result: null, trackingNumber: number) => void, (failureReason: any, trackingNumber: number) => void, (trackingNumber: number) => Promise<null>>;
         ensureLoadProcessTypes: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
     };

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

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

package/internal-do-not-import-from-here/stores/ShapeTemplateStore.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 { ShapeTemplate } from "../models";
 export declare class ShapeTemplateStore extends Store {
     private shapeTemplateService;
@@ -11,8 +11,8 @@ export declare class ShapeTemplateStore extends Store {
     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>>;
+        ensureLoadShapeTemplate: import("@omnia/fx/stores").StoreAction<unknown, (shapeTemplateId: guid, alwaysGetLatest?: boolean) => void, (result: ShapeTemplate, shapeTemplateId: guid, alwaysGetLatest?: boolean) => void, (failureReason: any, shapeTemplateId: guid, alwaysGetLatest?: boolean) => void, (shapeTemplateId: guid, alwaysGetLatest?: boolean) => Promise<ShapeTemplate>>;
+        addOrUpdateShapeTemplate: import("@omnia/fx/stores").StoreAction<unknown, (shapeTemplate: ShapeTemplate) => void, (result: unknown, shapeTemplate: ShapeTemplate) => void, (failureReason: any, shapeTemplate: ShapeTemplate) => void, (shapeTemplate: ShapeTemplate) => Promise<unknown>>;
         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;

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

@@ -0,0 +1,14 @@
+import { Store } from "@omnia/fx/stores";
+export declare class DocumentConversionStore extends Store {
+    private conversionSettingsPromise;
+    private supportCustomProvider;
+    getters: {
+        supportCustomProvider: () => boolean;
+    };
+    mutations: {};
+    actions: {
+        checkSupportCustomProvider: import("@omnia/fx/stores").StoreAction<unknown, (ensureFunc: Promise<boolean>) => void, (result: boolean, ensureFunc: Promise<boolean>) => void, (failureReason: any, ensureFunc: Promise<boolean>) => void, (ensureFunc: Promise<boolean>) => Promise<boolean>>;
+    };
+    onActivated(): void;
+    onDisposing(): void;
+}

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

@@ -0,0 +1,32 @@
+import { guid } from "@omnia/fx-models";
+import { Store } from "@omnia/fx/stores";
+import { SharePointField } from "../../models";
+import { DocumentSharePointFieldStore } from "./DocumentSharePointFieldStore";
+/**
+ * The store is using for process document properties *
+ * */
+export declare class DocumentPropetiesStore extends Store {
+    private enterprisePropertyStore;
+    private enterprisePropertySetStore;
+    private documentTypeStore;
+    documentSharePointFieldStore: DocumentSharePointFieldStore;
+    private teamworkContext;
+    private loadDocumentFieldsPromise;
+    private documentTypeField;
+    private documentTypeIdField;
+    private documentFields;
+    getters: {
+        documentFields: () => SharePointField[];
+        documentTypeFields: () => Array<SharePointField>;
+    };
+    mutations: {};
+    actions: {
+        ensureDocumentTypeFields: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeId: guid, fileUrl: string) => void, (result: void, documentTypeId: guid, fileUrl: string) => void, (failureReason: any, documentTypeId: guid, fileUrl: string) => void, (documentTypeId: guid, fileUrl: string) => Promise<void>>;
+        ensureDocumentFields: import("@omnia/fx/stores").StoreAction<unknown, (...args: string[]) => void, (result: void, ...args: string[]) => void, (failureReason: any, ...args: string[]) => void, (...fileUrls: string[]) => Promise<void>>;
+    };
+    private ensureLoadDocumentFields;
+    private processDocumentFields;
+    private getDocumentFieldsInSet;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,22 @@
+import { Store } from "@omnia/fx/stores";
+import { guid } from "@omnia/fx-models";
+import { SharePointField } from "../../models";
+export declare class DocumentSharePointFieldStore extends Store {
+    private documentService;
+    private enterprisePropertyStore;
+    private documents;
+    private SystemColumns;
+    getters: {
+        sharePointFields: (documentUrl: string) => SharePointField[];
+        existNotResolvedPersonFields: (documentUrl: any) => boolean;
+        cannotResolvePersonField: (documentUrl: string, id: guid) => boolean;
+        generateEnterpriseKeywordsFields: (fields: Array<SharePointField>) => Array<SharePointField>;
+        existEnterpriseKeywordsFields: (fields: Array<string>) => boolean;
+    };
+    mutations: {};
+    actions: {
+        ensureDocumentSharePointFields: import("@omnia/fx/stores").StoreAction<unknown, (documentUrl: string, siteUrl: string) => void, (result: any, documentUrl: string, siteUrl: string) => void, (failureReason: any, documentUrl: string, siteUrl: string) => void, (documentUrl: string, siteUrl: string) => Promise<any>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,37 @@
+import { Store } from "@omnia/fx/stores";
+import { DocumentTemplateCategory, DocumentTemplate, DocumentTemplateContent } from "../../models";
+export declare class DocumentTemplateStore extends Store {
+    private documentTemplateSerivice;
+    private documentTemplates;
+    private documentTemplateCategories;
+    private ensureLoadDocumentTemplatesPromise;
+    private ensureLoadDocumentTemplateCategoriesPromise;
+    private checkingMergedTemplatePromises;
+    private templateContentValidChecking;
+    getters: {
+        documentTemplates: () => DocumentTemplate[];
+        documentTemplateCategories: () => DocumentTemplateCategory[];
+        getShapeInFooterHeaderChecking: (template: DocumentTemplateContent) => boolean;
+    };
+    private privateMutations;
+    actions: {
+        ensureLoadDocumentTemplates: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureLoadDocumentTemplateCategories: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        addOrUpdateDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (result: any, documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (failureReason: any, documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => void, (documentTemplate: DocumentTemplate, files: {
+            [id: string]: File;
+        }) => Promise<any>>;
+        addOrUpdateDocumentTemplateCategory: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateCategory: DocumentTemplateCategory) => void, (result: any, documentTemplateCategory: DocumentTemplateCategory) => void, (failureReason: any, documentTemplateCategory: DocumentTemplateCategory) => void, (documentTemplateCategory: DocumentTemplateCategory) => Promise<any>>;
+        deleteDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplate: DocumentTemplate) => void, (result: any, documentTemplate: DocumentTemplate) => void, (failureReason: any, documentTemplate: DocumentTemplate) => void, (documentTemplate: DocumentTemplate) => Promise<any>>;
+        deleteDocumentTemplateCategory: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateCategory: DocumentTemplateCategory) => void, (result: any, documentTemplateCategory: DocumentTemplateCategory) => void, (failureReason: any, documentTemplateCategory: DocumentTemplateCategory) => void, (documentTemplateCategory: DocumentTemplateCategory) => Promise<any>>;
+        ensureCheckingTemplates: import("@omnia/fx/stores").StoreAction<unknown, (template: DocumentTemplateContent) => void, (result: void, template: DocumentTemplateContent) => void, (failureReason: any, template: DocumentTemplateContent) => void, (template: DocumentTemplateContent) => Promise<void>>;
+    };
+    protected onActivated(): void;
+    protected onDisposing(): void;
+    private getTemplateKey;
+}

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

@@ -0,0 +1,43 @@
+import { Store } from "@omnia/fx/stores";
+import { guid } from "@omnia/fx-models";
+import { DocumentType } from "../../models";
+export declare class DocumentTypeStore extends Store {
+    private documentTypeService;
+    private termStore;
+    private multilingualTextsStore;
+    private ensuredChildrenPromises;
+    private ensuredDocumentTypePromises;
+    private refreshCachePromises;
+    private ensureRootDocumentTypePromise;
+    private documentTypeTermSetId;
+    private documentTypes;
+    private documentTypesDict;
+    private documentTypesByDocumentTemplateDict;
+    private loadByDocumentTemplatesPromises;
+    getters: {
+        children: (parentId?: guid, includeInvalid?: boolean) => Array<DocumentType>;
+        byId: (id: guid, includeInvalid?: boolean) => DocumentType;
+        rootDocumentTypeInGlobalSettings: () => DocumentType;
+        SeachTypebyName: (search: string, language: string) => Array<DocumentType>;
+        documentTypesByDocumentTemplate: (documentTemplateId: guid) => Array<DocumentType>;
+    };
+    private isValidDocumentType;
+    private privateMutations;
+    private sortByChildrenOrders;
+    private ensureChildren;
+    actions: {
+        ensureRootDocumentType: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: null) => void, (failureReason: any) => void, () => Promise<null>>;
+        ensureChildren: import("@omnia/fx/stores").StoreAction<unknown, (parentId?: guid, moving?: boolean) => void, (result: null, parentId?: guid, moving?: boolean) => void, (failureReason: any, parentId?: guid, moving?: boolean) => void, (parentId?: guid, moving?: boolean) => Promise<null>>;
+        createDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: unknown, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<unknown>>;
+        updateDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: unknown, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<unknown>>;
+        removeDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: any, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<any>>;
+        ensureDocumentTypes: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeIds: guid[]) => void, (result: any, documentTypeIds: guid[]) => void, (failureReason: any, documentTypeIds: guid[]) => void, (documentTypeIds: Array<guid>) => Promise<any>>;
+        refreshCache: import("@omnia/fx/stores").StoreAction<unknown, (trackingNumber: number) => void, (result: null, trackingNumber: number) => void, (failureReason: any, trackingNumber: number) => void, (trackingNumber: number) => Promise<null>>;
+        ensureDocumentTypeByDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateId: guid) => void, (result: DocumentType[], documentTemplateId: guid) => void, (failureReason: any, documentTemplateId: guid) => void, (documentTemplateId: guid) => Promise<DocumentType[]>>;
+        getSpecificDocumentTypeById: import("@omnia/fx/stores").StoreAction<unknown, (documentTypeId: guid) => void, (result: unknown, documentTypeId: guid) => void, (failureReason: any, documentTypeId: guid) => void, (documentTypeId: guid) => Promise<unknown>>;
+    };
+    private isRootParentId;
+    private getParentId;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,85 @@
+import { Store } from "@omnia/fx/stores";
+import { guid } from "@omnia/fx-models";
+import { Enums, SharePointField, DocumentMetadataStatus, ProcessExistedDocumentAndMergeTemplateRequest, DocumentSharepointStatus, PublishedDocumentSharepointStatus } from "../../models";
+import { NewDocumentStore } from "./NewDocumentStore";
+import { DocumentPropetiesStore } from "./DocumentPropetiesStore";
+import { DocumentService } from "../../services";
+export declare class LibraryStore extends Store {
+    documentService: DocumentService;
+    private teamworkContext;
+    newDocumentStore: NewDocumentStore;
+    documentPropetiesStore: DocumentPropetiesStore;
+    private isLoadingDraft;
+    private isLoadingPublished;
+    private isLoadingRecycleBin;
+    private listItemsUserRoles;
+    private publishedLibraryUserRoles;
+    private ensureUpdatePropertiesPromises;
+    private publishDocumentPromises;
+    private creatingDraftPromises;
+    private documentStatusPromises;
+    private documentSharepointStatusPromises;
+    private documentsTitlePromises;
+    getters: {
+        isLoadingDraft: () => boolean;
+        isLoadingPublished: () => boolean;
+        isLoadingRecycleBin: () => boolean;
+        listItemsUserRoles: (library: string, id: number) => Array<{
+            [key: string]: Array<Enums.DocumentViewEnums.DocumentRoles>;
+        }>;
+        publishedLibraryUserRoles: () => Array<Enums.DocumentViewEnums.DocumentRoles>;
+        getDocumentStatus: (documents: Array<DocumentMetadataStatus>, siteUrl: string) => Array<DocumentMetadataStatus>;
+        isCreatingDraftStatus: (key: string) => boolean;
+        isPublishingDocument: (sqlId: guid, spWebUrl: string) => boolean;
+    };
+    mutations: {
+        setLoading: import("@omnia/fx/stores").StoreMutation<(isLoading: boolean, lib: string, siteUrl: string) => void, (isLoading: boolean, lib: string, siteUrl: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setListItemsUserRoles: import("@omnia/fx/stores").StoreMutation<(library: string, ids: number[], userRoles: Array<{
+            [id: number]: Array<Enums.DocumentViewEnums.DocumentRoles>;
+        }>) => void, (library: string, ids: number[], userRoles: {
+            [id: number]: Enums.DocumentViewEnums.DocumentRoles[];
+        }[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setPublishedLibraryUserRoles: import("@omnia/fx/stores").StoreMutation<(userRoles: Array<Enums.DocumentViewEnums.DocumentRoles>) => void, (userRoles: Enums.DocumentViewEnums.DocumentRoles[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        forceReloadDocumentStatus: import("@omnia/fx/stores").StoreMutation<(lib: string, siteUrl: string) => void, (lib: string, siteUrl: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        forceReloadDocument: import("@omnia/fx/stores").StoreMutation<(lib: string, siteUrl: string, sqlId: guid) => void, (lib: string, siteUrl: string, sqlId: guid) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updatePublishPromises: import("@omnia/fx/stores").StoreMutation<(sqlId: guid, siteUrl: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus) => void, (sqlId: guid, siteUrl: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateCreatingDraftPromises: import("@omnia/fx/stores").StoreMutation<(id: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus, msg?: string) => void, (id: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus, msg?: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        clearPublishDocumentPromises: import("@omnia/fx/stores").StoreMutation<() => void, () => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        resetDocumentStatusPromises: import("@omnia/fx/stores").StoreMutation<(url: string, libraryName: string) => void, (url: string, libraryName: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensureUpdateDocumentProperties: import("@omnia/fx/stores").StoreAction<unknown, (absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: guid, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (result: string, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: guid, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (failureReason: any, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: guid, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: guid, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<string>>;
+        ensureDocumentStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: {
+            [key: string]: guid;
+        }, libraryName: string) => void, (result: DocumentMetadataStatus[], url: string, params: {
+            [key: string]: guid;
+        }, libraryName: string) => void, (failureReason: any, url: string, params: {
+            [key: string]: guid;
+        }, libraryName: string) => void, (url: string, params: {
+            [key: string]: guid;
+        }, libraryName: string) => Promise<DocumentMetadataStatus[]>>;
+        ensureDocumentSharepointStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: number[], libraryName: string) => void, (result: {
+            [key: number]: DocumentSharepointStatus;
+        }, url: string, params: number[], libraryName: string) => void, (failureReason: any, url: string, params: number[], libraryName: string) => void, (url: string, params: Array<number>, libraryName: string) => Promise<{
+            [key: number]: DocumentSharepointStatus;
+        }>>;
+        ensureDocumentTitleStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: number[], libraryName: string) => void, (result: {
+            [key: number]: string;
+        }, url: string, params: number[], libraryName: string) => void, (failureReason: any, url: string, params: number[], libraryName: string) => void, (url: string, params: Array<number>, libraryName: string) => Promise<{
+            [key: number]: string;
+        }>>;
+        ensurePublishedDocumentSharepointStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (result: PublishedDocumentSharepointStatus[], url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (failureReason: any, url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => void, (url: string, params: {
+            [key: number]: number;
+        }, libraryName: string, loadAppendix: boolean, loadSignedDocument: boolean) => Promise<PublishedDocumentSharepointStatus[]>>;
+        ensureRetoreDraftDocuments: import("@omnia/fx/stores").StoreAction<unknown, (documentIds: string[]) => void, (result: void, documentIds: string[]) => void, (failureReason: any, documentIds: string[]) => void, (documentIds: string[]) => Promise<void>>;
+    };
+    private getUserRolesKey;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}

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

@@ -0,0 +1,36 @@
+import { Store } from "@omnia/fx/stores";
+import { guid } from "@omnia/fx-models";
+import { SharePointField } from "../../models";
+/**
+ * The store is using for sharing data between tabs
+ * And we don't cache data here, we reload the latest document value everytime
+ *
+ * */
+export declare class NewDocumentStore extends Store {
+    private enterprisePropertyStore;
+    private enterprisePropertySetStore;
+    private teamAppPropertyService;
+    private documentTypeStore;
+    private documentTypeId;
+    private fields;
+    private loadSiteFieldsPromise;
+    getters: {
+        fields: () => SharePointField[];
+        documentTypeId: () => guid;
+    };
+    mutations: {
+        setCurrentDocument: import("@omnia/fx/stores").StoreMutation<(fields: Array<SharePointField>) => void, (fields: SharePointField[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updateDocumentTypeId: import("@omnia/fx/stores").StoreMutation<(id: guid) => void, (id: guid) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    actions: {
+        ensureLoadFields: import("@omnia/fx/stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
+    };
+    private getDocumentFieldsInSet;
+    private mergeDefaultValue;
+    private prepareDefaultValues;
+    private getSharePointFieldWithFromSiteDefaultValue;
+    private getSharePointFieldWithFixedDefaultValue;
+    private ensureLoadSitePropertiesFields;
+    protected onActivated(): void;
+    protected onDisposing(): void;
+}