@omnia/management-system 7.6.11-preview → 7.6.11

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

@@ -0,0 +1,15 @@
+import { GuidValue, Identity } from "@omnia/fx/models";
+import { DocumentType } from "../../models";
+export declare class DocumentTypeService {
+    private httpClient;
+    constructor();
+    refreshServerCache: () => Promise<void>;
+    getByIds: (ids: Array<GuidValue>) => Promise<Array<DocumentType>>;
+    getChildren: (parentId?: GuidValue) => Promise<Array<DocumentType>>;
+    getDocumentTypeTermSetId: () => Promise<GuidValue>;
+    create: (documentType: DocumentType) => Promise<DocumentType>;
+    update: (documentType: DocumentType) => Promise<DocumentType>;
+    remove: (id: GuidValue) => Promise<void>;
+    getUsersInApproverGroup: (docTypeId: GuidValue, webUrl: string) => Promise<Identity[]>;
+    getByDocumentTemplateId: (documentTemplateId: GuidValue) => Promise<Array<DocumentType>>;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { ApprovalTask, PublishDocumentWithApprovalRequest, Workflow } from "../../models";
+export declare class ApprovalTaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getApprovalTaskById: (itemId: number, webUrl: string) => Promise<ApprovalTask>;
+    completeApprovalTask: (task: ApprovalTask) => Promise<string>;
+    cancelWorkflow: (documentReview: Workflow) => Promise<void>;
+    publishDocumentWithApproval: (request: PublishDocumentWithApprovalRequest) => Promise<void>;
+    processCompletingApprovalTask: (task: ApprovalTask) => Promise<void>;
+    processCancellingApprovalWorkflow: (approval: Workflow) => Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { GuidValue } from "@omnia/fx/models";
+import { MergeMetadataRequest, DocumentRequest, SharePointField, SPList, GetControlledDocumentsResponse, WorkflowHistory, SPSite } from "../../models";
+export declare class DocumentLibraryService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    filterDraftDocuments: (request: DocumentRequest, openInClientApp: boolean) => Promise<GetControlledDocumentsResponse>;
+    filterPublishedDocuments: (request: DocumentRequest, openInClientApp: boolean) => Promise<GetControlledDocumentsResponse>;
+    filterDeletedDocuments: (request: DocumentRequest) => Promise<GetControlledDocumentsResponse>;
+    getLibraryWithFields: (webUrl: string, listUrl: string) => Promise<SPList>;
+    getFilteringOptionsPage: (webUrl: string, listId: string, fieldName: string, viewId: string) => Promise<string>;
+    getNextTaxonomyFilteringHierarchy: (siteUrl: string, listId: string, fieldId: string, termId: string) => Promise<string>;
+    getRestOfFilteringHierarchy: (webUrl: string, listId: string, fieldId: string, termId: string) => Promise<string>;
+    getDisplayFieldsInList: (webUrl: string, listUrl: string) => Promise<SharePointField[]>;
+    getTestFile: () => Promise<void>;
+    mergeMetadataToDocument: (mergeRequest: MergeMetadataRequest, fileData: ArrayBuffer) => Promise<void>;
+    testConvertToPDF: () => Promise<void>;
+    getWorkflowHistories: (sqlId: GuidValue) => Promise<WorkflowHistory[]>;
+    isExistingDraftDocument: (webUrl: string, odmDocId: string) => Promise<boolean>;
+    resolveAuthoringSite: (webUrl: string) => Promise<SPSite>;
+}

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

@@ -0,0 +1,15 @@
+import { GuidValue } from "@omnia/fx/models";
+import { DocumentNotifiedPerson, DocumentReadReceiptsHistory, Enums, PublishDocumentWithoutApprovalRequest, MoveDocumentToTargetSiteRequest, PreviewPublishedDocumentRequest } from "../../models";
+export declare class PublishDocumentService {
+    private httpClient;
+    constructor();
+    fixPublishingFailedDocument: (webUrl: string, odmDocumentId: string, sqlId: GuidValue) => Promise<void>;
+    checkPrePublishCondition: (webUrl: string, spDocumentId: number, sqlId: GuidValue, status: Enums.DocumentViewEnums.LibraryDocumentStatus) => Promise<boolean>;
+    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: GuidValue, isReadAndUnderstood: boolean) => Promise<void>;
+    setMovingToTargetSiteDocumentStatus: (sqlDocumentId: string, odmDocumentId: string, currentSiteUrl: string, targetSiteUrl: string) => Promise<Enums.DocumentViewEnums.LibraryDocumentStatus>;
+    movePageToTargetSite: (moveDocumentRequest: MoveDocumentToTargetSiteRequest) => Promise<void>;
+}

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 { GuidValue } from "@omnia/fx/models";
+import { Workflow, DocumentTaskDetail, TaskRequest, TaskItemResponse, Enums } from "../../models";
+export declare class TaskService {
+    private httpClient;
+    private emptyHttpClient;
+    constructor();
+    getFilterTasks: (request: TaskRequest) => Promise<TaskItemResponse>;
+    getTaskById: (webUrl: string, taskId: number) => Promise<DocumentTaskDetail>;
+    getDocumentWorkflow: (spDocumentId: number, sqlId: GuidValue, webUrl: string, workflowType?: Enums.DocumentViewEnums.WorkflowType) => Promise<Workflow>;
+    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/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 { GuidValue } 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: GuidValue, fileUrl: string) => void, (result: void, documentTypeId: GuidValue, fileUrl: string) => void, (failureReason: any, documentTypeId: GuidValue, fileUrl: string) => void, (documentTypeId: GuidValue, 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 { GuidValue } 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: GuidValue) => 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,42 @@
+import { Store } from "@omnia/fx/stores";
+import { GuidValue } 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?: GuidValue, includeInvalid?: boolean) => Array<DocumentType>;
+        byId: (id: GuidValue, includeInvalid?: boolean) => DocumentType;
+        rootDocumentTypeInGlobalSettings: () => DocumentType;
+        SeachTypebyName: (search: string, language: string) => Array<DocumentType>;
+        documentTypesByDocumentTemplate: (documentTemplateId: GuidValue) => 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?: GuidValue, moving?: boolean) => void, (result: null, parentId?: GuidValue, moving?: boolean) => void, (failureReason: any, parentId?: GuidValue, moving?: boolean) => void, (parentId?: GuidValue, moving?: boolean) => Promise<null>>;
+        createDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: DocumentType, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<DocumentType>>;
+        updateDocumentType: import("@omnia/fx/stores").StoreAction<unknown, (documentType: DocumentType) => void, (result: DocumentType, documentType: DocumentType) => void, (failureReason: any, documentType: DocumentType) => void, (documentType: DocumentType) => Promise<DocumentType>>;
+        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: GuidValue[]) => void, (result: any, documentTypeIds: GuidValue[]) => void, (failureReason: any, documentTypeIds: GuidValue[]) => void, (documentTypeIds: 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>>;
+        ensureDocumentTypeByDocumentTemplate: import("@omnia/fx/stores").StoreAction<unknown, (documentTemplateId: GuidValue) => void, (result: DocumentType[], documentTemplateId: GuidValue) => void, (failureReason: any, documentTemplateId: GuidValue) => void, (documentTemplateId: GuidValue) => Promise<DocumentType[]>>;
+    };
+    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 { GuidValue } 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) => {
+            [key: string]: Enums.DocumentViewEnums.DocumentRoles[];
+        }[];
+        publishedLibraryUserRoles: () => Array<Enums.DocumentViewEnums.DocumentRoles>;
+        getDocumentStatus: (documents: Array<DocumentMetadataStatus>, siteUrl: string) => Array<DocumentMetadataStatus>;
+        isCreatingDraftStatus: (key: string) => boolean;
+        isPublishingDocument: (sqlId: GuidValue, 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: {
+            [id: number]: 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: GuidValue) => void, (lib: string, siteUrl: string, sqlId: GuidValue) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        updatePublishPromises: import("@omnia/fx/stores").StoreMutation<(sqlId: GuidValue, siteUrl: string, value: Enums.DocumentViewEnums.LibraryDocumentStatus) => void, (sqlId: GuidValue, 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: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (result: string, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (failureReason: any, absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => void, (absoluteUrl: string, fileUrl: string, fields: SharePointField[], documentTypeFields: SharePointField[], odmDocId: string, sqlId: GuidValue, isUpdateDocStatus: boolean, forceRefresh?: boolean, mergeSettings?: ProcessExistedDocumentAndMergeTemplateRequest) => Promise<string>>;
+        ensureDocumentStatus: import("@omnia/fx/stores").StoreAction<unknown, (url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (result: DocumentMetadataStatus[], url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (failureReason: any, url: string, params: {
+            [key: string]: GuidValue;
+        }, libraryName: string) => void, (url: string, params: {
+            [key: string]: GuidValue;
+        }, 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 { GuidValue } 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: () => GuidValue;
+    };
+    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: GuidValue) => void, (id: GuidValue) => 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;
+}

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

@@ -0,0 +1,7 @@
+export * from "./DocumentTypeStore";
+export * from "./LibraryStore";
+export * from "./DocumentSharePointFieldStore";
+export * from "./DocumentTemplateStore";
+export * from "./NewDocumentStore";
+export * from "./DocumentPropetiesStore";
+export * from "./DocumentConversionStore";

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

@@ -5,3 +5,4 @@ export * from "./ProcessTypeStore";
 export * from "./SettingsStore";
 export * from "./ShapeTemplateStore";
 export * from "./ProcessTemplateLayoutStore";
+export * from "./documentlibrary";

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

@@ -1,7 +1,8 @@
-import { ProcessStep, Process, ProcessReference, RootProcessStep, InternalProcessStep, DrawingShapeDefinition } from "../fx/models";
+import { ProcessStep, Process, ProcessReference, RootProcessStep, InternalProcessStep, DrawingShapeDefinition } from "./models";
 import { GuidValue } from "@omnia/fx-models";
 import { MultilingualStore } from "@omnia/fx/stores";
 import { MultilingualString } from "@omnia/fx/models";
+import { RecentDocumentType } from "../models";
 export declare module OPMUtils {
     function generateProcessStepExpandState(processStep: RootProcessStep, processStepId: GuidValue): {
         [processStepId: string]: true;
@@ -26,4 +27,15 @@ export declare module OPMUtils {
     function parentFrameIsMsTeams(): boolean;
     function IsOpenEditorPreview(): boolean;
     function buildContextIdentifier(appId: GuidValue, processRoute: string): string;
+    function getMaximumLengthOfMultilingualString(multilingualString: MultilingualString): number;
+}
+export declare module ODMUtils {
+    function orderBy(input: any, [config]: [string?]): any;
+    function getOfficeClientPrefix(extension: string): string;
+    function saveRecentDocumentType(documentTypeId: GuidValue): void;
+    function getRecentDocumentTypes(): Array<RecentDocumentType>;
+    function isSupportedByOfficeWebApp(fileExtension: string): boolean;
+    function isSupportedByOfficeWebAppWithMsTeams(fileExtension: string): boolean;
+    function correctDateOnlyValue(dateValue: any): Date;
+    function isAllowedToConvertToPDF(fileExtension: string): boolean;
 }

package/package.json

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

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

@@ -1,33 +0,0 @@
-export declare const OPMEnterprisePropertyInternalNames: {
-    readonly OPMEdition: string;
-    readonly OPMRevision: string;
-    readonly OPMProcessType: string;
-    readonly OPMProcessIdNumber: string;
-    readonly OPMPublished: string;
-    readonly OPMApprovedBy: string;
-    readonly OPMIsArchived: string;
-    readonly OPMIsPublished: string;
-};
-export declare const OPMProcessProperty: {
-    readonly Id: string;
-};
-export declare module Security {
-    const OPMRoleDefinitions: {
-        readonly Author: string;
-        readonly Reader: string;
-        readonly Approver: string;
-        readonly Reviewer: string;
-    };
-    const OPMResourceEvaluators: {
-        readonly SecurityResourceIdResource: string;
-        readonly OPMProcessIdResource: string;
-    };
-    const Parameters: {
-        readonly OPMProcessId: string;
-        readonly SecurityResourceId: string;
-    };
-    const ODMRoleDefinitions: {
-        readonly AppInstanceAuthor: string;
-        readonly AppInstanceReader: string;
-    };
-}

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Security = exports.OPMProcessProperty = exports.OPMEnterprisePropertyInternalNames = void 0;
-exports.OPMEnterprisePropertyInternalNames = {
-    get OPMEdition() { return "OPMEdition"; },
-    get OPMRevision() { return "OPMRevision"; },
-    get OPMProcessType() { return "OPMProcessType"; },
-    get OPMProcessIdNumber() { return "OPMProcessIdNumber"; },
-    get OPMPublished() { return "OPMPublished"; },
-    get OPMApprovedBy() { return "OPMApprovedBy"; },
-    get OPMIsArchived() { return "OPMIsArchived"; },
-    get OPMIsPublished() { return "OPMIsPublished"; }
-};
-exports.OPMProcessProperty = {
-    get Id() { return "7491ec1a-9cf5-4c49-b102-2f84f89795eb"; }
-};
-var Security;
-(function (Security) {
-    Security.OPMRoleDefinitions = {
-        get Author() { return "f412d0be-16e8-4fc2-80cf-dca39a265a08"; },
-        get Reader() { return "38c86dbf-44a2-45c4-b370-2c1cabea954c"; },
-        get Approver() { return "22672fb9-e62f-470c-a68d-77ae03a5115d"; },
-        get Reviewer() { return "89e89b72-a75c-41d2-8303-b83800980faa"; }
-    };
-    Security.OPMResourceEvaluators = {
-        get SecurityResourceIdResource() { return "Omnia.ManagementSystem.Web.Security.ResourceEvaluators.ISecurityResourceIdResourceEvaluator"; },
-        get OPMProcessIdResource() { return "Omnia.ManagementSystem.Web.Security.ResourceEvaluators.IOPMProcessIdResourceEvaluator"; }
-    };
-    Security.Parameters = {
-        get OPMProcessId() { return "opmProcessId"; },
-        get SecurityResourceId() { return "opmSecurityResourceId"; }
-    };
-    Security.ODMRoleDefinitions = {
-        get AppInstanceAuthor() { return "86c0c947-91e5-45aa-b85e-4ea8a9a31b07"; },
-        get AppInstanceReader() { return "cde81de4-58b0-4fe5-a45f-ed66138cb64c"; }
-    };
-})(Security = exports.Security || (exports.Security = {}));