@acorex/modules 21.0.0-next.15 → 21.0.0-next.16

package/fesm2022/acorex-modules-document-management.mjs

@@ -1,7 +1,7 @@
 import { AXPSessionService, AXPAuthGuard, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
 import { AXPEntityService, AXMEntityCrudServiceImpl, entityMasterCrudActions, entityMasterRecordActions, cloneLayoutArrays, ensureLayoutSection, ensureLayoutPropertyView, ensureListActions, actionExists, AXPEntityDefinitionRegistryService, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import { AXPHookService, AXPPlatformScope, AXPDataGenerator, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXPDeviceService, resolvePlatformScopeKey, resolvePlatformScopeName } from '@acorex/platform/core';
-import { AXPSearchCommandProvider, createAllQueryView, AXPFileTypeProviderService, AXP_FILE_TYPE_INFO_PROVIDER, AXPFileStorageService, AXPFilterOperatorMiddlewareService, AXPSettingsService, AXPLockService, UploadFromComputerActionProvider, AXP_FILE_ACTION_PROVIDER, AXPEntityCommandScope, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPSearchCommandProvider, createAllQueryView, createQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXPFileTypeProviderService, AXP_FILE_TYPE_INFO_PROVIDER, AXPFileStorageService, AXPFilterOperatorMiddlewareService, AXPSettingsService, AXPLockService, UploadFromComputerActionProvider, AXP_FILE_ACTION_PROVIDER, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import * as i0 from '@angular/core';
 import { Injectable, inject, Injector, NgModule, ChangeDetectionStrategy, Component, signal, computed, viewChild, input, effect, ViewEncapsulation, untracked, HostListener } from '@angular/core';
 import * as i3$2 from '@acorex/core/translation';
@@ -10,6 +10,7 @@ import { firstValueFrom } from 'rxjs';
 import * as i6 from '@acorex/platform/layout/widget-core';
 import { AXPWidgetsCatalog, AXPValueWidgetComponent, AXPWidgetCoreModule, AXP_WIDGETS_ADVANCE_CATEGORY } from '@acorex/platform/layout/widget-core';
 import { RouterModule, ROUTES, Router, ActivatedRoute } from '@angular/router';
+import { set, castArray, get as get$1 } from 'lodash-es';
 import { AXDataSource } from '@acorex/cdk/common';
 import * as i7 from '@acorex/components/collapse';
 import { AXCollapseModule } from '@acorex/components/collapse';
@@ -24,15 +25,8 @@ import { AXSelectBoxModule } from '@acorex/components/select-box';
 import * as i2 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 import get from 'lodash-es/get';
-import set from 'lodash-es/set';
+import set$1 from 'lodash-es/set';
 import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/layout/widgets';
-import { AXDialogService } from '@acorex/components/dialog';
-import { AXPopupService } from '@acorex/components/popup';
-import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
-import * as i3$1 from '@acorex/platform/workflow';
-import { AXPWorkflowService, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
-import { AXFileService, AXFileModule } from '@acorex/core/file';
-import { castArray, get as get$1, set as set$1 } from 'lodash-es';
 import * as i2$2 from '@acorex/components/media-viewer';
 import { AXMediaViewerModule } from '@acorex/components/media-viewer';
 import * as i1$1 from '@acorex/components/button';
@@ -48,6 +42,12 @@ import { AXPStateMessageComponent, AXPThemeLayoutBlockComponent } from '@acorex/
 import { AXPLayoutThemeService } from '@acorex/platform/themes/shared';
 import * as i1$2 from '@angular/common';
 import { CommonModule } from '@angular/common';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
+import * as i3$1 from '@acorex/platform/workflow';
+import { AXPWorkflowService, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import { AXFileService, AXFileModule } from '@acorex/core/file';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
 import { AXUploaderService } from '@acorex/cdk/uploader';
 import { AXBadgeModule } from '@acorex/components/badge';
@@ -72,6 +72,18 @@ const RootConfig = {
         icon: 'fa-light fa-books',
     },
     entities: {
+        documentRelated: {
+            name: 'DocumentRelated',
+            title: `@${config.i18n}:entities.document.title`,
+            titlePlural: `@${config.i18n}:entities.document.title-plural`,
+            icon: 'fa-light fa-default',
+        },
+        review: {
+            name: 'Review',
+            title: `@${config.i18n}:entities.review.title`,
+            titlePlural: `@${config.i18n}:entities.review.title-plural`,
+            icon: 'fa-light fa-file-pen',
+        },
         folder: {
             name: 'Folder',
             title: `@${config.i18n}:entities.folder.title`,
@@ -90,6 +102,24 @@ const RootConfig = {
             titlePlural: `@${config.i18n}:entities.document-type.title-plural`,
             icon: 'fa-light fa-books',
         },
+        documentTypeMetaDefinition: {
+            name: 'documentTypeMeta',
+            title: `@${config.i18n}:entities.document-type-meta.title`,
+            titlePlural: `@${config.i18n}:entities.document-type-meta.title-plural`,
+            icon: 'fa-light fa-meta',
+        },
+        documentTypeMetaValue: {
+            name: 'documentTypeMetaValue',
+            title: `@${config.i18n}:entities.document-type-meta-value.title`,
+            titlePlural: `@${config.i18n}:entities.document-type-meta-value.title-plural`,
+            icon: 'fa-light fa-meta',
+        },
+        documentTypeStatus: {
+            name: 'documentTypeStatus',
+            title: `@${config.i18n}:entities.document-type-status.title`,
+            titlePlural: `@${config.i18n}:entities.document-type-status.title-plural`,
+            icon: 'fa-light fa-status',
+        },
     },
 };
 
@@ -164,6 +194,13 @@ const AXMPermissionsKeys = {
             Delete: 'DocumentManagement:Permission:Driver.Delete',
             Create: 'DocumentManagement:Permission:Driver.Create',
         },
+        Review: {
+            Management: 'DocumentManagement:Permission:Review.Management',
+            View: 'DocumentManagement:Permission:Review.View',
+            Edit: 'DocumentManagement:Permission:Review.Edit',
+            Delete: 'DocumentManagement:Permission:Review.Delete',
+            Create: 'DocumentManagement:Permission:Review.Create',
+        },
     },
 };
 
@@ -189,6 +226,13 @@ class AXMPermissionDefinitionProvider {
             .addChild(keys.Driver.Edit, await trans('driver.edit.title'), await trans('driver.edit.description'))
             .addChild(keys.Driver.Delete, await trans('driver.delete.title'), await trans('driver.delete.description'))
             .addChild(keys.Driver.Create, await trans('driver.create.title'), await trans('driver.create.description'))
+            .endPermission()
+            //
+            .addPermission(keys.Review.Management, await trans('review.manage.title'), await trans('review.manage.description'))
+            .addChild(keys.Review.View, await trans('review.view.title'), await trans('review.view.description'))
+            .addChild(keys.Review.Edit, await trans('review.edit.title'), await trans('review.edit.description'))
+            .addChild(keys.Review.Delete, await trans('review.delete.title'), await trans('review.delete.description'))
+            .addChild(keys.Review.Create, await trans('review.create.title'), await trans('review.create.description'))
             .endPermission();
         //
     }
@@ -289,21 +333,25 @@ class AXMEntityProvider {
         }));
     }
     async get(moduleName, entityName) {
-        if (moduleName === RootConfig.module.name) {
+        if (moduleName == RootConfig.module.name) {
             switch (entityName) {
+                case RootConfig.entities.document.name:
+                    return (await Promise.resolve().then(function () { return index; })).documentFactory(this.injector);
                 case RootConfig.entities.documentType.name:
                     return (await Promise.resolve().then(function () { return index; })).documentTypeFactory(this.injector);
                 case RootConfig.entities.folder.name:
-                    return (await Promise.resolve().then(function () { return folder_entity; })).folderEntityFactory(this.injector);
-                case RootConfig.entities.document.name:
-                    return (await Promise.resolve().then(function () { return document_entity; })).documentEntityFactory(this.injector);
+                    return (await Promise.resolve().then(function () { return index; })).folderFactory(this.injector);
+                case RootConfig.entities.review.name:
+                    return (await Promise.resolve().then(function () { return index; })).reviewFactory(this.injector);
+                case RootConfig.entities.documentRelated.name:
+                    return (await Promise.resolve().then(function () { return index; })).documentRelatedFactory(this.injector);
             }
         }
         return null;
     }
     async list() {
         const m = RootConfig.module.name;
-        const entities = [RootConfig.entities.documentType];
+        const entities = Object.values(RootConfig.entities);
         return Promise.resolve(entities.map((e) => ({ name: e.name, module: m })));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -332,37 +380,6 @@ class AXMSearchCommandProvider extends AXPSearchCommandProvider {
     }
 }
 
-/**
- * Minimal entity definition for Document so the entity registry can resolve
- * DocumentManagement.Document. Used by AXMDocumentService (AXMEntityCrudServiceImpl).
- * No list/form UI; documents are handled by document-explorer.
- */
-async function documentEntityFactory(_injector) {
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.document.name,
-        title: RootConfig.entities.document.title,
-        parentKey: 'parentId',
-        formats: {
-            individual: RootConfig.entities.document.title,
-            plural: RootConfig.entities.document.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        relatedEntities: [],
-        groups: [],
-        properties: [],
-    };
-    return entityDef;
-}
-
-var document_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    documentEntityFactory: documentEntityFactory
-});
-
 class AXMDocumentService extends AXMEntityCrudServiceImpl {
 }
 class AXMDocumentServiceImpl extends AXMDocumentService {
@@ -376,15 +393,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
-async function documentTypeFactory(injector) {
+var document_service = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentService: AXMDocumentService,
+    AXMDocumentServiceImpl: AXMDocumentServiceImpl
+});
+
+async function documentFactory(injector) {
+    const dataService = injector.get(AXMDocumentService);
     const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.documentType.name,
-        title: RootConfig.entities.documentType.title,
+        name: RootConfig.entities.document.name,
+        title: RootConfig.entities.document.title,
+        icon: RootConfig.entities.document.icon,
         formats: {
-            individual: RootConfig.entities.documentType.title,
-            plural: RootConfig.entities.documentType.titlePlural,
+            individual: RootConfig.entities.review.title,
+            plural: RootConfig.entities.review.titlePlural,
             searchResult: {
                 title: '{{ title }}',
                 description: RootConfig.module.title,
@@ -393,50 +418,62 @@ async function documentTypeFactory(injector) {
         plugins: [
             { name: 'history' },
             {
-                name: 'meta-data-selector'
+                name: 'attachments',
+                options: {
+                    multiple: false,
+                    field: 'fileId',
+                },
             },
+            { name: 'meta-data-form', options: { path: 'typeId' } }
         ],
-        relatedEntities: [],
-        groups: [
+        relatedEntities: [
             {
-                id: 'basic-info',
-                title: RootConfig.entities.documentType.title,
+                entity: `${RootConfig.module.name}.${RootConfig.entities.review.name}`,
+                conditions: [
+                    {
+                        name: 'documentId',
+                        operator: {
+                            type: 'equal',
+                        },
+                        value: '{{context.eval("id")}}',
+                    },
+                ],
+                // hidden: '{{context.eval("toggle")}}',
+                actions: [],
             },
+        ],
+        groups: [
             {
-                id: 'management',
-                title: `@${i18n}:terms.common.management`,
+                id: 'section',
+                title: RootConfig.entities.document.title,
             },
         ],
         properties: [
             {
                 name: 'name',
                 title: '@general:terms.common.name',
-                groupId: 'basic-info',
+                groupId: 'section',
                 options: {
                     sort: {
                         enabled: true,
                     },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
+                    filter: {
+                        inline: {
+                            enabled: true,
+                        },
+                        advance: {
+                            enabled: true,
+                        },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
+                    readonly: true,
                     interface: {
                         type: AXPWidgetsCatalog.text,
+                        options: {
+                            placeholder: '@general:terms.common.name',
+                        },
                     },
                 },
                 validations: [
@@ -446,34 +483,16 @@ async function documentTypeFactory(injector) {
                 ],
             },
             {
-                name: 'maxSize',
-                title: `@${i18n}:terms.document.max-size`,
-                groupId: 'basic-info',
+                name: 'typeId',
+                title: '@general:terms.common.type',
+                groupId: 'section',
                 schema: {
-                    dataType: 'number',
+                    dataType: 'string',
+                    readonly: true,
                     interface: {
-                        type: AXPWidgetsCatalog.numberUnit,
+                        type: AXPWidgetsCatalog.lookup,
                         options: {
-                            textField: 'name',
-                            valueField: 'value',
-                            dataSource: [
-                                {
-                                    name: 'kb',
-                                    value: 'KB',
-                                    calUnit: 1,
-                                },
-                                {
-                                    name: 'mb',
-                                    value: 'MB',
-                                    calUnit: 1024,
-                                },
-                                {
-                                    name: 'gb',
-                                    value: 'GB',
-                                    calUnit: 1024 * 1024,
-                                },
-                            ],
-                            mainUnit: 'kb',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.documentType.name}`,
                         },
                     },
                 },
@@ -484,181 +503,2485 @@ async function documentTypeFactory(injector) {
                 ],
             },
             {
-                name: 'isEncrypted',
-                title: `@${i18n}:terms.document.is-encrypted`,
-                groupId: 'basic-info',
+                name: 'version',
+                title: `@${i18n}:terms.common.version`,
+                groupId: 'section',
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'number',
+                    readonly: true,
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog.number,
+                        options: {},
                     },
                 },
             },
             {
-                name: 'enableExpiration',
-                title: `@${i18n}:terms.document.enable-expiration`,
-                groupId: 'management',
+                name: 'size',
+                title: `@${i18n}:terms.common.size`,
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'number',
+                    readonly: true,
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog.number,
+                        options: {},
                     },
                 },
             },
             {
-                name: 'requiresReview',
-                title: `@${i18n}:terms.document.requires-review`,
-                groupId: 'management',
-                schema: {
-                    dataType: 'boolean',
-                    interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                name: 'status',
+                title: `@${i18n}:terms.common.status`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        inline: {
+                            enabled: true,
+                        },
+                        advance: {
+                            enabled: true,
+                        },
                     },
                 },
-            },
-            {
-                name: 'enableVersioning',
-                title: `@${i18n}:terms.document.enable-versioning`,
-                groupId: 'management',
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'string',
+                    readonly: true,
                     interface: {
-                        type: AXPWidgetsCatalog.toggle,
+                        type: AXPWidgetsCatalog.text,
                         options: {
-                            disabled: '{{ !!context.eval("requiresReview") }}',
+                            content: `{{ context.eval('status') }}`,
                         },
-                        triggers: [
-                            {
-                                event: "{{ events.context('requiresReview') }}",
-                                action: "{{ context.set('enableVersioning', true) }}",
-                            },
-                        ],
                     },
                 },
             },
-            // {
-            //   name: 'meta',
-            //   title: `t("metaTitle", { scope: "${i18n}" })`,
-            //   groupId: 'section',
-            //   schema: {
-            //     dataType: 'object',
-            //     interface: {
-            //       type: 'meta-selector-editor',
-            //     },
-            //   },
-            // },
-            {
-                name: 'type',
-                title: `@${i18n}:terms.common.type`,
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.fileTypeExtension,
-                        options: {},
-                    },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'status' },
+            { name: 'version' },
+        ],
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    const x = await dataService.getOne(id);
+                    x.fileId = [x.fileId];
+                    set(x, 'typeId', x.documentType.id);
+                    return x;
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const filter = e.filter;
+                    // Base filter for requiresReview
+                    const baseFilters = [
+                        {
+                            field: 'documentType.requiresReview',
+                            operator: { type: 'equal' },
+                            value: true,
+                        },
+                    ];
+                    // Check if e.filter has filters array with items
+                    const hasAdditionalFilters = filter?.filters && Array.isArray(filter.filters) && filter.filters.length > 0;
+                    // Combine filters if additional filters exist
+                    const allFilters = hasAdditionalFilters
+                        ? [...baseFilters, ...filter.filters]
+                        : baseFilters;
+                    const x = await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: {
+                            logic: 'and',
+                            filters: allFilters,
+                        },
+                    });
+                    return x;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'typeId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                // update: {
+                //   sections: [
+                //     {
+                //       id: 'section',
+                //     },
+                //   ],
+                //   properties: [
+                //     {
+                //       name: 'name',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 6,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'type',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'metaData',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //           },
+                //         },
+                //       },
+                //     },
+                //     {
+                //       name: 'file',
+                //       layout: {
+                //         positions: {
+                //           lg: {
+                //             colSpan: 12,
+                //           },
+                //         },
+                //       },
+                //     },
+                //   ],
+                // },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'typeId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        // {
+                        //   name: 'fileId',
+                        //   layout: {
+                        //     positions: {
+                        //       lg: {
+                        //         colSpan: 12,
+                        //       },
+                        //     },
+                        //   },
+                        // },
+                        // {
+                        //   name: 'file',
+                        //   layout: {
+                        //     positions: {
+                        //       lg: {
+                        //         colSpan: 12,
+                        //       },
+                        //     },
+                        //   },
+                        // },
+                        {
+                            name: 'status',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: '@general:actions.detail.title',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            default: true,
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({ sorts: [{ name: 'name', dir: 'asc' }] }),
+                        createQueryView('Draft', `@${i18n}:terms.workflow.draft`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'Draft',
+                                },
+                            ],
+                        }),
+                        createQueryView('PendingReview', `@${i18n}:terms.workflow.pending`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'PendingReview',
+                                },
+                            ],
+                        }),
+                        createQueryView('Reviewed', `@${i18n}:terms.workflow.reviewed`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'Reviewed',
+                                },
+                            ],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentManagementDocumentEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, providers: [
+            {
+                provide: AXMDocumentService,
+                useClass: AXMDocumentServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentService,
+                            useClass: AXMDocumentServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+function getNextStatus(options) {
+    const { current, requiresReview, reviewFirst, reviewResult, } = options;
+    switch (current) {
+        case 'Draft':
+            if (requiresReview)
+                return 'PendingReview';
+            return 'Completed';
+        case 'PendingReview':
+            if (reviewResult === 'rejected')
+                return 'Rejected';
+            if (reviewResult === 'approved') {
+                return 'Completed';
+            }
+            return null;
+        case 'Reviewed':
+            return 'Completed';
+        default:
+            return null;
+    }
+}
+const AXMDocumentWorkflowTransitionMap = {
+    Draft: ['PendingReview', 'Completed'],
+    PendingReview: ['Reviewed', 'Rejected'],
+    Rejected: ['PendingReview'], // پس از اصلاح
+    Reviewed: ['Completed', 'Distributed'],
+    Distributed: ['Completed'],
+    Completed: [],
+};
+function canTransition(from, to) {
+    return AXMDocumentWorkflowTransitionMap[from]?.includes(to) ?? false;
+}
+
+async function documentTypeFactory(injector) {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.documentType.name,
+        title: RootConfig.entities.documentType.title,
+        formats: {
+            individual: RootConfig.entities.documentType.title,
+            plural: RootConfig.entities.documentType.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        plugins: [
+            { name: 'history' },
+            {
+                name: 'meta-data-selector'
+            },
+        ],
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'basic-info',
+                title: RootConfig.entities.documentType.title,
+            },
+            {
+                id: 'management',
+                title: `@${i18n}:terms.common.management`,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'maxSize',
+                title: `@${i18n}:terms.document.max-size`,
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog.numberUnit,
+                        options: {
+                            textField: 'name',
+                            valueField: 'value',
+                            dataSource: [
+                                {
+                                    name: 'kb',
+                                    value: 'KB',
+                                    calUnit: 1,
+                                },
+                                {
+                                    name: 'mb',
+                                    value: 'MB',
+                                    calUnit: 1024,
+                                },
+                                {
+                                    name: 'gb',
+                                    value: 'GB',
+                                    calUnit: 1024 * 1024,
+                                },
+                            ],
+                            mainUnit: 'kb',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'isEncrypted',
+                title: `@${i18n}:terms.document.is-encrypted`,
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
+            {
+                name: 'enableExpiration',
+                title: `@${i18n}:terms.document.enable-expiration`,
+                groupId: 'management',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
+            {
+                name: 'requiresReview',
+                title: `@${i18n}:terms.document.requires-review`,
+                groupId: 'management',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
+            {
+                name: 'enableVersioning',
+                title: `@${i18n}:terms.document.enable-versioning`,
+                groupId: 'management',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                        options: {
+                            disabled: '{{ !!context.eval("requiresReview") }}',
+                        },
+                        triggers: [
+                            {
+                                event: "{{ events.context('requiresReview') }}",
+                                action: "{{ context.set('enableVersioning', true) }}",
+                            },
+                        ],
+                    },
+                },
+            },
+            // {
+            //   name: 'meta',
+            //   title: `t("metaTitle", { scope: "${i18n}" })`,
+            //   groupId: 'section',
+            //   schema: {
+            //     dataType: 'object',
+            //     interface: {
+            //       type: 'meta-selector-editor',
+            //     },
+            //   },
+            // },
+            {
+                name: 'type',
+                title: `@${i18n}:terms.common.type`,
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.fileTypeExtension,
+                        options: {},
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'management',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableExpiration',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'requiresReview',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableVersioning',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        // {
+                        //   name: 'meta',
+                        //   layout: {
+                        //     positions: {
+                        //       lg: {
+                        //         colSpan: 12,
+                        //       },
+                        //     },
+                        //   },
+                        // },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'management',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableExpiration',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'requiresReview',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableVersioning',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'basic-info',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            id: 'management',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableExpiration',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'requiresReview',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'enableVersioning',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        // {
+                        //   name: 'meta',
+                        //   layout: {
+                        //     positions: {
+                        //       lg: {
+                        //         colSpan: 12,
+                        //       },
+                        //     },
+                        //   },
+                        // },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions({ edit: true })],
+                    views: [createAllQueryView()],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentTypeService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentTypeServiceImpl extends AXMDocumentTypeService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentType.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMDocumentManagementDocumentTypeEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, providers: [
+            {
+                provide: AXMDocumentTypeService,
+                useClass: AXMDocumentTypeServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentTypeService,
+                            useClass: AXMDocumentTypeServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+async function documentTypeMetaDefinitionfactory(injector) {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.document.name,
+        title: RootConfig.entities.document.title,
+        formats: {
+            individual: RootConfig.entities.document.title,
+            plural: RootConfig.entities.document.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl extends AXMDocumentManagementDocumentTypeMetaDefinitionEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeMetaDefinition}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+                useClass: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+async function documentTypeMetaValueFactory(injector) {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.document.name,
+        title: RootConfig.entities.document.title,
+        formats: {
+            individual: RootConfig.entities.document.title,
+            plural: RootConfig.entities.document.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentManagementDocumentTypeMetaValueEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl extends AXMDocumentManagementDocumentTypeMetaValueEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeMetaValue}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMDocumentManagementDocumentTypeMetaValueEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+                useClass: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+async function documentTypeStatusDefinitionFactory(injector) {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.document.name,
+        title: RootConfig.entities.document.title,
+        formats: {
+            individual: RootConfig.entities.document.title,
+            plural: RootConfig.entities.document.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl extends AXMDocumentManagementDocumentTypeStatusDefinitionEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeStatus}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+                useClass: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+async function documentRelatedFactory(injector) {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.documentRelated.name,
+        title: RootConfig.entities.documentRelated.title,
+        icon: RootConfig.entities.documentRelated.icon,
+        formats: {
+            individual: RootConfig.entities.documentRelated.title,
+            plural: RootConfig.entities.documentRelated.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.documentRelated.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            placeholder: '@general:terms.common.name',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'size',
+                title: '@general:terms.common.size',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.number,
+                        options: {},
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'type',
+                title: '@general:terms.common.type',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.documentType.name}`,
+                            expose: 'type',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'metaData',
+                title: `@${i18n}:terms.common.meta-data`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'object',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.blockLayout,
+                        options: {},
+                        // children: 'context.eval("type.meta")'
+                        children: []
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'fileId',
+                title: `@${i18n}:terms.common.file`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.fileUploader,
+                        options: {
+                            maxFileSize: ` {{context.eval("type.maxSize")}} `,
+                            multiple: ` {{context.eval("type.multiple")}} `,
+                            //  accept: ` {{context.eval("type.multiple")}} `,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'fileId' },
+            { name: 'type' },
+            { name: 'size' }
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'fileId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                }
+                            },
+                        },
+                        {
+                            name: 'fileId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: '@general:actions.detail.title',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            default: true,
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({ sorts: [{ name: 'name', dir: 'asc' }] }),
+                        createQueryView('Draft', `@${i18n}:terms.workflow.draft`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'Draft',
+                                },
+                            ],
+                        }),
+                        createQueryView('PendingReview', `@${i18n}:terms.workflow.pending`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'PendingReview',
+                                },
+                            ],
+                        }),
+                        createQueryView('Reviewed', `@${i18n}:terms.workflow.reviewed`, true, {
+                            conditions: [
+                                {
+                                    name: 'status',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 'Reviewed',
+                                },
+                            ],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMFolderService extends AXMEntityCrudServiceImpl {
+}
+class AXMFolderServiceImpl extends AXMFolderService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.folder.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function folderFactory(injector) {
+    const dataService = injector.get(AXMFolderService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.folder.name,
+        title: RootConfig.entities.folder.title,
+        formats: {
+            individual: RootConfig.entities.folder.title,
+            plural: RootConfig.entities.folder.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.folder.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query(e);
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMFolderEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderEntityModule, providers: [
+            {
+                provide: AXMFolderService,
+                useClass: AXMFolderServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMFolderService,
+                            useClass: AXMFolderServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMReviewService extends AXMEntityCrudServiceImpl {
+}
+class AXMReviewServiceImpl extends AXMReviewService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.review.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+// Helper function to update document status based on review status
+async function updateDocumentStatus(documentId, reviewStatus, injector) {
+    try {
+        // Import document service dynamically to avoid circular dependencies
+        const { AXMDocumentService } = await Promise.resolve().then(function () { return document_service; });
+        const documentService = injector.get(AXMDocumentService);
+        // Map review status to document workflow phase
+        let documentStatus;
+        switch (reviewStatus) {
+            case 'Approved':
+                documentStatus = 'Reviewed';
+                break;
+            case 'Rejected':
+                documentStatus = 'Rejected';
+                break;
+            case 'Pending':
+                documentStatus = 'PendingReview';
+                break;
+            default:
+                documentStatus = 'PendingReview';
+        }
+        // Update the document status
+        await documentService.updateOne(documentId, { status: documentStatus });
+    }
+    catch (error) {
+        console.error('Failed to update document status:', error);
+        // Don't throw error to avoid breaking the review process
+    }
+}
+async function reviewFactory(injector) {
+    const dataService = injector.get(AXMReviewService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.review.name,
+        title: RootConfig.entities.review.title,
+        icon: RootConfig.entities.review.icon,
+        formats: {
+            individual: RootConfig.entities.review.title,
+            plural: RootConfig.entities.review.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.review.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'version',
+                title: `@${i18n}:terms.common.version`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog.textBlockLayout,
+                        options: {
+                            content: `{{ context.eval('version') }}`,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'documentId',
+                groupId: 'section',
+                title: `@${i18n}:entities.document.title`,
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.document.name}`,
+                            multiple: false,
+                            filter: "{{ { logic:'and' , filters: [ { field:'documentType.requiresReview' , value: true , operator: { type:'equal' } },] } }}",
+                            textField: 'name',
+                            valueField: 'id',
+                            expose: [
+                                { source: 'id', target: 'document.id' },
+                                { source: 'name', target: 'document.name' },
+                                { source: 'title', target: 'document.title' },
+                                { source: 'version', target: 'document.version' },
+                            ],
+                        },
+                        triggers: [
+                            {
+                                event: "{{ events.context('documentId') }}",
+                                action: "{{ context.set('version' , context.eval('document').version ) }}",
+                            },
+                        ],
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'reviewerId',
+                title: `@${i18n}:terms.common.reviewer`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    defaultValue: '{{ session.currentUser().id }}',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'SecurityManagement.User',
+                            multiple: false,
+                            textField: 'username',
+                            valueField: 'id',
+                            expose: [
+                                { source: 'id', target: 'reviewer.id' },
+                                { source: 'username', target: 'reviewer.username' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'status',
+                title: `@${i18n}:terms.workflow.approve`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                        options: {},
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'comment',
+                title: `@${i18n}:terms.common.comment`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                    },
+                },
+            },
+            {
+                name: 'reviewedAt',
+                title: `@${i18n}:terms.timestamps.reviewed-at`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    defaultValue: '{{ variables.execute("now") }}',
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            showTime: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'auditInfo.updated.at',
+                title: `@${i18n}:terms.timestamps.modified-at`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            showTime: true,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'auditInfo.updated.by',
+                title: `@${i18n}:terms.timestamps.modified-by`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'SecurityManagement.User',
+                            multiple: false,
+                            textField: 'username',
+                            valueField: 'id',
+                            expose: [
+                                { source: 'id', target: 'auditInfo.updated.by.id' },
+                                { source: 'username', target: 'auditInfo.updated.by.username' },
+                            ],
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'reviewerId', options: { dataPath: 'reviewer.title' } },
+            { name: 'status' },
+            { name: 'comment' },
+            { name: 'reviewedAt' },
+            { name: 'auditInfo.updated.at' },
+            { name: 'auditInfo.updated.by', options: { dataPath: 'auditInfo.updated.by.fullName' } },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    // Set reviewedAt to current date if not provided
+                    if (!data.reviewedAt) {
+                        data.reviewedAt = new Date();
+                    }
+                    //TODO for test
+                    data.reviewStatus = 'Approved';
+                    // Create the review record
+                    const res = await dataService.insertOne(data);
+                    // Update document status based on review status
+                    await updateDocumentStatus(data.documentId, data.reviewStatus, injector);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    // Update reviewedAt to current date
+                    data.reviewedAt = new Date();
+                    //TODO for test
+                    data.reviewStatus = 'Approved';
+                    // Update the review record
+                    const result = await dataService.updateOne(data.id, data);
+                    // Update document status based on review status
+                    await updateDocumentStatus(data.documentId, data.reviewStatus, injector);
+                    return result;
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    const review = await dataService.getOne(id);
+                    return {
+                        ...review,
+                        reviewedAt: review.reviewedAt ?? new Date(),
+                    };
                 },
+                type: AXPEntityQueryType.Single,
             },
-        ],
-        columns: [{ name: 'name' }, { name: 'title' }],
+            list: {
+                execute: async (e) => {
+                    return await dataService.query(e);
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
         interfaces: {
             master: {
                 create: {
                     sections: [
                         {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'management',
+                            id: 'section',
                         },
                     ],
                     properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
+                            name: 'documentId',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
+                                        order: 1,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'maxSize',
+                            name: 'reviewerId',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 5,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'isEncrypted',
+                            name: 'version',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 2,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'enableExpiration',
+                            name: 'status',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 3,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'requiresReview',
+                            name: 'comment',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
+                                        order: 4,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'enableVersioning',
+                            name: 'reviewedAt',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        // {
-                        //   name: 'meta',
-                        //   layout: {
-                        //     positions: {
-                        //       lg: {
-                        //         colSpan: 12,
-                        //       },
-                        //     },
-                        //   },
-                        // },
-                        {
-                            name: 'type',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
+                                        order: 6,
                                     },
                                 },
                             },
@@ -668,89 +2991,39 @@ async function documentTypeFactory(injector) {
                 update: {
                     sections: [
                         {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'management',
+                            id: 'section',
                         },
                     ],
                     properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'maxSize',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'isEncrypted',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'enableExpiration',
+                            name: 'reviewerId',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 5,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'requiresReview',
+                            name: 'comment',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
+                                        order: 4,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'enableVersioning',
+                            name: 'reviewedAt',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'type',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
+                                        order: 6,
                                     },
                                 },
                             },
@@ -758,20 +3031,10 @@ async function documentTypeFactory(injector) {
                     ],
                 },
                 single: {
-                    title: '{{title}}',
+                    title: '{{document.name}} - Review',
                     sections: [
                         {
-                            id: 'basic-info',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            id: 'management',
+                            id: 'section',
                             layout: {
                                 positions: {
                                     lg: {
@@ -783,101 +3046,104 @@ async function documentTypeFactory(injector) {
                     ],
                     properties: [
                         {
-                            name: 'name',
+                            name: 'documentId',
+                            dataPath: 'document',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
+                                        order: 1,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'title',
+                            name: 'reviewerId',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 5,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'maxSize',
+                            name: 'version',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 2,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'isEncrypted',
+                            name: 'status',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 3,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'enableExpiration',
+                            name: 'comment',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
+                                        order: 4,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'requiresReview',
+                            name: 'reviewedAt',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'enableVersioning',
+                            name: 'auditInfo.updated.at',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
+                                        order: 7,
                                     },
                                 },
                             },
                         },
-                        // {
-                        //   name: 'meta',
-                        //   layout: {
-                        //     positions: {
-                        //       lg: {
-                        //         colSpan: 12,
-                        //       },
-                        //     },
-                        //   },
-                        // },
                         {
-                            name: 'type',
+                            name: 'auditInfo.updated.by',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
+                                        order: 8,
                                     },
                                 },
                             },
                         },
                     ],
-                    actions: [...entityMasterRecordActions()],
+                    actions: [],
                 },
                 list: {
-                    actions: [...entityMasterCrudActions({ edit: true })],
-                    views: [createAllQueryView()],
+                    actions: [],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'reviewedAt', dir: 'desc' }],
+                        }),
+                    ],
                 },
             },
         },
@@ -885,30 +3151,17 @@ async function documentTypeFactory(injector) {
     return entityDef;
 }
 
-class AXMDocumentTypeService extends AXMEntityCrudServiceImpl {
-}
-class AXMDocumentTypeServiceImpl extends AXMDocumentTypeService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.documentType.name}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentTypeServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class AXMDocumentManagementDocumentTypeEntityModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, providers: [
+class AXMReviewEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewEntityModule, providers: [
             {
-                provide: AXMDocumentTypeService,
-                useClass: AXMDocumentTypeServiceImpl,
+                provide: AXMReviewService,
+                useClass: AXMReviewServiceImpl,
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReviewEntityModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
@@ -916,71 +3169,64 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                     declarations: [],
                     providers: [
                         {
-                            provide: AXMDocumentTypeService,
-                            useClass: AXMDocumentTypeServiceImpl,
+                            provide: AXMReviewService,
+                            useClass: AXMReviewServiceImpl,
                         },
                     ],
                 }]
         }] });
 
-/**
- * Minimal entity definition for Folder so the entity registry can resolve
- * DocumentManagement.Folder. Used by AXMFolderService (AXMEntityCrudServiceImpl).
- * No list/form UI; folder tree is handled by document-explorer.
- */
-async function folderEntityFactory(_injector) {
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.folder.name,
-        title: RootConfig.entities.folder.title,
-        parentKey: 'parentId',
-        formats: {
-            individual: RootConfig.entities.folder.title,
-            plural: RootConfig.entities.folder.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        relatedEntities: [],
-        groups: [],
-        properties: [],
-    };
-    return entityDef;
-}
-
-var folder_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    folderEntityFactory: folderEntityFactory
-});
-
-class AXMFolderService extends AXMEntityCrudServiceImpl {
-}
-class AXMFolderServiceImpl extends AXMFolderService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.folder.name}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl }); }
+class AXMDocumentReletedEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentReletedEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentReletedEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentReletedEntityModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFolderServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentReletedEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [],
+                }]
+        }] });
 
 // Entity Services
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    AXMDocumentManagementDocumentEntityModule: AXMDocumentManagementDocumentEntityModule,
     AXMDocumentManagementDocumentTypeEntityModule: AXMDocumentManagementDocumentTypeEntityModule,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityService: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+    AXMDocumentManagementDocumentTypeMetaValueEntityModule: AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+    AXMDocumentManagementDocumentTypeMetaValueEntityService: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+    AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityService: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+    AXMDocumentReletedEntityModule: AXMDocumentReletedEntityModule,
     AXMDocumentService: AXMDocumentService,
     AXMDocumentServiceImpl: AXMDocumentServiceImpl,
     AXMDocumentTypeService: AXMDocumentTypeService,
     AXMDocumentTypeServiceImpl: AXMDocumentTypeServiceImpl,
+    AXMFolderEntityModule: AXMFolderEntityModule,
     AXMFolderService: AXMFolderService,
     AXMFolderServiceImpl: AXMFolderServiceImpl,
-    documentEntityFactory: documentEntityFactory,
+    AXMReviewEntityModule: AXMReviewEntityModule,
+    AXMReviewService: AXMReviewService,
+    AXMReviewServiceImpl: AXMReviewServiceImpl,
+    canTransition: canTransition,
+    documentFactory: documentFactory,
+    documentRelatedFactory: documentRelatedFactory,
     documentTypeFactory: documentTypeFactory,
-    folderEntityFactory: folderEntityFactory
+    documentTypeMetaDefinitionfactory: documentTypeMetaDefinitionfactory,
+    documentTypeMetaValueFactory: documentTypeMetaValueFactory,
+    documentTypeStatusDefinitionFactory: documentTypeStatusDefinitionFactory,
+    folderFactory: folderFactory,
+    getNextStatus: getNextStatus,
+    reviewFactory: reviewFactory
 });
 
 class AXMImageFileTypeProvider {
@@ -1425,14 +3671,14 @@ class AXMFileTypeExtensionWidgetEditComponent extends AXPValueWidgetComponent {
                 if (extension.meta) {
                     for (const meta of extension.meta) {
                         if (!get(meta, '__node__')) {
-                            set(meta, '__node__', typeof meta.interface == 'function' ? await meta.interface() : meta.interface);
+                            set$1(meta, '__node__', typeof meta.interface == 'function' ? await meta.interface() : meta.interface);
                         }
                     }
                 }
                 if (fileType.meta) {
                     for (const meta of fileType.meta) {
                         if (!get(meta, '__node__')) {
-                            set(meta, '__node__', typeof meta.interface == 'function' ? await meta.interface() : meta.interface);
+                            set$1(meta, '__node__', typeof meta.interface == 'function' ? await meta.interface() : meta.interface);
                         }
                     }
                 }
@@ -1753,6 +3999,85 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                 }]
         }] });
 
+//#region ---- Imports ----
+//#endregion
+/**
+ * File gallery popup component that displays files using the gallery widget.
+ * This component replaces the old file-viewer-popup and uses the same
+ * gallery widget pattern as test8.
+ */
+class AXMFileGalleryPopupComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        //#region ---- Class Properties ----
+        /** File list items received from popup data */
+        this.files = signal([], ...(ngDevMode ? [{ debugName: "files" }] : []));
+        /** Starting index for the media viewer */
+        this.startIndex = 0;
+        /** Widget context for the gallery */
+        this.context = signal({}, ...(ngDevMode ? [{ debugName: "context" }] : []));
+        //#endregion
+        //#region ---- Computed Properties ----
+        /**
+         * Gallery widget node configuration
+         */
+        this.galleryNode = computed(() => ({
+            type: 'gallery',
+            path: 'galleryFiles',
+            defaultValue: this.files(),
+            options: {
+                thumbnail: true,
+                header: true,
+                fileInfo: true,
+                fullScreenButton: true,
+                allowUpload: false,
+                height: '100%',
+            },
+        }), ...(ngDevMode ? [{ debugName: "galleryNode" }] : []));
+    }
+    //#endregion
+    //#region ---- UI Handlers ----
+    /**
+     * Close the popup
+     */
+    onClose() {
+        this.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFileGalleryPopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: AXMFileGalleryPopupComponent, isStandalone: true, selector: "axm-file-gallery-popup", usesInheritance: true, ngImport: i0, template: `
+    <ax-content>
+      <axp-widgets-container class="ax-block ax-h-full" [context]="context()">
+        <ng-container axp-widget-renderer [node]="galleryNode()" [mode]="'edit'"></ng-container>
+      </axp-widgets-container>
+    </ax-content>
+    <ax-footer>
+      <ax-suffix>
+        <ax-button [text]="'close'" (click)="onClose()" />
+      </ax-suffix>
+    </ax-footer>
+  `, isInline: true, styles: [":host{display:block;height:100%}ax-content{height:calc(100% - 60px)}\n"], dependencies: [{ kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: i6.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i6.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged", "onLoad"], exportAs: ["widgetRenderer"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFileGalleryPopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-file-gallery-popup', template: `
+    <ax-content>
+      <axp-widgets-container class="ax-block ax-h-full" [context]="context()">
+        <ng-container axp-widget-renderer [node]="galleryNode()" [mode]="'edit'"></ng-container>
+      </axp-widgets-container>
+    </ax-content>
+    <ax-footer>
+      <ax-suffix>
+        <ax-button [text]="'close'" (click)="onClose()" />
+      </ax-suffix>
+    </ax-footer>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [AXDecoratorModule, AXButtonModule, AXPWidgetCoreModule], styles: [":host{display:block;height:100%}ax-content{height:calc(100% - 60px)}\n"] }]
+        }] });
+
+var fileGalleryPopup_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMFileGalleryPopupComponent: AXMFileGalleryPopupComponent
+});
+
 class AXPDocumentManagementService {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPDocumentManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPDocumentManagementService }); }
@@ -1844,12 +4169,13 @@ class AXMDocumentDialogService {
                     const promises = (ctx?.['files']).map(async (item, index) => {
                         const f = fileList[index];
                         const newId = await this.documentService.insertOne({
-                            fileInfo: f,
+                            fileId: f,
                             name: f?.name,
                             title: f?.title ?? f?.name,
                             description: f?.description,
                             documentType,
                             parentId,
+                            size: f?.size || 0,
                             status: 'Draft',
                             version: (version ?? 0) + 1,
                             metaDataForm: ctx?.[`file-${index}`]?.['metaDataForm'],
@@ -2011,9 +4337,7 @@ class DocumentAttachmentsService {
             parentId: options?.folderId ?? '',
             version: 0,
         };
-        const title = await this.translateService.translateAsync('@document-management:dialogs.attach-file.title', {
-            params: { title: fileTypeEntity.title },
-        });
+        const title = await this.translateService.translateAsync('@document-management:dialogs.attach-file.title', { params: { title: fileTypeEntity.title } });
         const result = await this.documentDialog.openAttachmentDialog(title, popupData);
         return this.handlePopupResult(result);
     }
@@ -2022,10 +4346,10 @@ class DocumentAttachmentsService {
         if (!file) {
             throw new Error('File not found');
         }
-        const documentTypeEntity = await this.resolveFileType(file.documentType);
+        console.log(file);
         const popupData = {
-            documentType: documentTypeEntity,
-            files: [file.fileInfo],
+            documentType: file.documentType,
+            files: [file.fileId],
             parentId: options?.folderId ?? '',
             metaData: file.metaDataForm,
             documentId: fileId,
@@ -2043,16 +4367,15 @@ class DocumentAttachmentsService {
         if (!document) {
             throw new Error('File not found');
         }
-        const documentTypeEntity = await this.resolveFileType(document.documentType);
         // Choose a single new file based on document type constraints
-        const files = await this.chooseFiles(documentTypeEntity, false);
+        const files = await this.chooseFiles(document.documentType, false);
         if (!files || files.length === 0) {
             return false;
         }
         const mapped = this.mapFilesToFileListItems(files);
         // Open a lightweight dialog to edit metadata (no auto-save); then apply update with new file
         const result = await this.documentDialog.openAttachmentDialogWithoutSave('@document-management:dialogs.manage-version.upload-new-version', {
-            documentType: documentTypeEntity,
+            documentType: document.documentType,
             files: mapped,
             parentId: document.parentId,
             metaData: document.metaDataForm,
@@ -2065,7 +4388,8 @@ class DocumentAttachmentsService {
         const metaDataForm = document.metaDataForm;
         const newName = files[0]?.name ?? document.name;
         await this.documentService.updateOne(fileId, {
-            fileInfo: mapped[0],
+            fileId: mapped[0],
+            size: files[0]?.size ?? document.size,
             version: (document.version ?? 0) + 1,
             metaDataForm,
             name: newName,
@@ -2079,16 +4403,19 @@ class DocumentAttachmentsService {
         }
     }
     async resolveFileType(fileType) {
-        const id = typeof fileType === 'string' ? fileType : fileType.id;
-        const entity = await this.documentTypeService.getOne(id);
-        if (!entity) {
-            throw new Error(`Document type not found: ${id}`);
+        if (typeof fileType === 'string' || typeof fileType === 'number') {
+            const fileTypeId = fileType;
+            const fileTypeEntity = await this.documentTypeService.getOne(fileTypeId);
+            if (!fileTypeEntity) {
+                throw new Error('File type not found');
+            }
+            return fileTypeEntity;
         }
-        return entity;
+        return fileType;
     }
     async chooseFiles(fileTypeEntity, multiple) {
-        const selectedItems = fileTypeEntity.type?.selectedItems ?? [];
-        const acceptTypes = selectedItems.map((item) => `.${item.name.split('.')[1]}`).join(',');
+        console.log(fileTypeEntity.type.selectedItems);
+        const acceptTypes = fileTypeEntity.type.selectedItems.map((item) => `.${item.name.split('.')[1]}`).join(',');
         return await this.fileService.choose({
             multiple: multiple ?? false,
             accept: acceptTypes,
@@ -2125,25 +4452,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
 
 //#region ----   Imports   ----
 //#endregion
-//#region ----   Contract (Abstract Service)   ----
-/**
- * Contract for document drive service. Inject this token; implementation is provided by the module.
- */
-class AXMDocumentManagerService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService, decorators: [{
-            type: Injectable
-        }] });
-//#endregion
 //#region ----   Service Implementation   ----
 /**
- * Default implementation of document drive service.
+ * Service for handling document drive operations
  */
-class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
+class AXMDocumentManagerService {
     constructor() {
-        super(...arguments);
         //#region ----   Services & Dependencies   ----
         this.folderService = inject(AXMFolderService);
         this.sessionService = inject(AXPSessionService);
@@ -2157,6 +4471,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
         this.workflow = inject(AXPWorkflowService);
         this.translate = inject(AXTranslationService);
         this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.reviewService = inject(AXMReviewService);
         this.attachmentsService = inject(DocumentAttachmentsService);
         this.filterMiddlewareService = inject(AXPFilterOperatorMiddlewareService);
         this.hooks = inject(AXPHookService, { optional: true });
@@ -2172,13 +4487,13 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
         this.mapFolderDtoToFolderNode = (folder) => {
             return {
                 id: folder.id,
-                name: folder.title,
+                name: folder.name,
                 type: 'folder',
                 parentId: folder.parentId || null,
                 modifiedAt: folder?.updated?.at,
                 createdAt: folder?.created?.at,
                 description: folder.description,
-                childrenCount: folder.childrenCount,
+                childrenCount: folder.nodeCount,
                 size: folder.size,
                 documentTypes: folder.documentTypes || [],
                 storageType: 'physical',
@@ -2193,14 +4508,98 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
     //#endregion
     //#region ----   Scope Management Methods   ----
     /**
-     * Creates a scoped drive service for the specified platform scope.
-     * Backend resolves tenant/user from request context (client sends only scope).
+     * Creates a scoped drive service for the specified platform scope
+     */
+    scope(scope, options) {
+        const cacheKey = this.getScopeCacheKey(scope, options);
+        if (!this.scopedDriveCache.has(cacheKey)) {
+            this.scopedDriveCache.set(cacheKey, new ScopedDriveService(this, scope, options));
+        }
+        return this.scopedDriveCache.get(cacheKey);
+    }
+    /**
+     * Generates a cache key for the scoped drive service
+     */
+    getScopeCacheKey(scope, options) {
+        return scope;
+    }
+    //#endregion
+    //#region ----   Private Helper Methods   ----
+    /**
+     * Gets the platform root folder (top-level folder)
+     */
+    async getPlatformRootFolder() {
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: [
+                    { field: 'parentId', operator: { type: 'isNull' } },
+                    { field: 'tenantId', operator: { type: 'isNull' } },
+                    { field: 'userId', operator: { type: 'isNull' } },
+                ],
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('Platform root folder not found');
+        }
+        return result.items[0];
+    }
+    /**
+     * Gets the tenant root folder
      */
-    scope(scope) {
-        if (!this.scopedDriveCache.has(scope)) {
-            this.scopedDriveCache.set(scope, new ScopedDriveService(this, scope));
+    async getTenantRootFolder(rootFolder, tenantId) {
+        if (!tenantId) {
+            throw new Error('Tenant ID is required');
         }
-        return this.scopedDriveCache.get(scope);
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: this.filterMiddlewareService.transformFilters([
+                    {
+                        field: 'parentId',
+                        operator: { type: 'equal' },
+                        value: rootFolder.folders?.find((f) => f.name === 'Tenants')?.id,
+                    },
+                    { field: 'tenantId', operator: { type: 'equal' }, value: tenantId },
+                    { field: 'userId', operator: { type: 'isNull' } },
+                ]),
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('Tenant root folder not found');
+        }
+        return result.items[0];
+    }
+    /**
+     * Gets the user root folder
+     */
+    async getUserRootFolder(tenantFolderId, tenantId, userId) {
+        if (!tenantId || !userId) {
+            throw new Error('Both Tenant ID and User ID are required');
+        }
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: this.filterMiddlewareService.transformFilters([
+                    { field: 'parentId', operator: { type: 'equal' }, value: tenantFolderId },
+                    { field: 'tenantId', operator: { type: 'equal' }, value: tenantId },
+                    { field: 'userId', operator: { type: 'equal' }, value: userId },
+                ]),
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('User root folder not found');
+        }
+        return result.items[0];
     }
     /**
      * Maps file entity to document explorer node
@@ -2213,8 +4612,8 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             parentId: file.parentId,
             modifiedAt: file?.updated?.at,
             createdAt: file?.created?.at,
-            size: file.fileInfo?.size ?? 0,
-            fileId: file.fileInfo,
+            size: file.size,
+            fileId: file.fileId,
             storageType: 'physical',
             meta: file.metaDataForm ? Object.values(file.metaDataForm) : undefined,
             documentTypes: file.documentType ? [file.documentType] : [],
@@ -2224,46 +4623,33 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
      * Maps document to media viewer data
      */
     async mapDocumentToMediaViewerData(doc, fileInfosMap) {
-        const f = doc.fileInfo ?? doc.fileId;
-        const fileIdStr = f == null
-            ? undefined
-            : typeof f === 'string'
-                ? f
-                : f.source?.kind === 'fileId' &&
-                    typeof f.source?.value === 'string'
-                    ? f.source.value
-                    : typeof f.id === 'string'
-                        ? f.id
-                        : undefined;
-        if (fileIdStr) {
+        if (doc.fileId?.source?.kind == 'fileId') {
+            const fileId = doc.fileId.source.value;
             let fileInfo;
             if (fileInfosMap) {
-                fileInfo = fileInfosMap.get(fileIdStr);
+                // Use pre-fetched data
+                fileInfo = fileInfosMap.get(fileId);
             }
             else {
-                fileInfo = await this.fileService.getInfo(fileIdStr);
+                // Fallback to individual fetch (for backward compatibility)
+                fileInfo = await this.fileService.getInfo(fileId);
             }
-            const resolvedSize = fileInfo?.size ?? doc?.fileId?.size ?? 0;
             return {
                 id: doc.id ?? '',
                 name: doc.name,
                 type: doc.name.endsWith('.pdf') ? 'pdf' : 'image',
                 url: fileInfo?.url ?? '',
-                size: resolvedSize.toString(),
+                size: doc.size.toString(),
                 thumbnailUrl: fileInfo?.url ?? '',
             };
         }
-        const fallbackUrl = doc?.fileId?.source?.kind === 'url' && typeof doc.fileId.source.value === 'string'
-            ? doc.fileId.source.value
-            : '';
-        const fallbackSize = doc?.fileId?.size ?? 0;
         return {
             id: doc.id ?? '',
             name: doc.name,
             type: doc.meta?.['type'] ?? 'image',
-            url: fallbackUrl,
-            size: fallbackSize.toString(),
-            thumbnailUrl: fallbackUrl,
+            url: doc.fileId ?? '',
+            size: doc.size.toString(),
+            thumbnailUrl: doc.fileId ?? '',
         };
     }
     //#endregion
@@ -2301,8 +4687,9 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
         return `${nameWithoutExt} copy${extension}`;
     }
     /**
-     * Prepares file for copy operation by downloading from storage and converting to blob source.
-     * Accepts document fileId (AXPFileListItem or legacy string) and returns AXPFileListItem with blob source.
+     * Prepares file for copy operation by downloading from storage and converting to blob source
+     * This method takes an existing AXPFileListItem (or fileId string) and prepares it for re-upload
+     * by downloading the file from storage and changing source to blob with uploading status
      */
     async prepareFileForCopy(fileId, fileName) {
         try {
@@ -2322,6 +4709,9 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
                     fileIdString = fileId.id;
                     existingFileItem = fileId;
                 }
+                else if (fileId.fileId && typeof fileId.fileId === 'string') {
+                    fileIdString = fileId.fileId;
+                }
             }
             if (!fileIdString) {
                 console.warn('Could not extract fileId from:', fileId);
@@ -2370,20 +4760,45 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
     //#endregion
     //#region ----   Root and Folder Operations   ----
     /**
-     * Gets the root folder for the given scope.
-     * Backend returns only the root folder; path is built here for the explorer.
+     * Gets the root folder based on the specified scope
      */
-    async getRoot(scope) {
-        const rootFolder = await this.documentManagementService.getRoot(scope);
-        const result = this.mapFolderDtoToFolderNode(rootFolder);
-        const path = await this.buildPath(result);
+    async getRoot(scope, options) {
+        const rootFolder = await this.getPlatformRootFolder();
+        let result;
+        let path = [];
+        switch (scope) {
+            case AXPPlatformScope.Platform:
+                result = this.mapFolderDtoToFolderNode(rootFolder);
+                path = await this.buildPath(result);
+                break;
+            case AXPPlatformScope.Tenant: {
+                if (!options?.tenantId) {
+                    throw new Error('Tenant ID is required for tenant scope');
+                }
+                const tenantRoot = await this.getTenantRootFolder(rootFolder, options.tenantId);
+                result = this.mapFolderDtoToFolderNode(tenantRoot);
+                path = await this.buildPath(result, tenantRoot.id);
+                break;
+            }
+            case AXPPlatformScope.User: {
+                if (!options?.tenantId || !options?.userId) {
+                    throw new Error('Both Tenant ID and User ID are required for user scope');
+                }
+                const tenantFolder = await this.getTenantRootFolder(rootFolder, options.tenantId);
+                const userRoot = await this.getUserRootFolder(tenantFolder.folders?.find((f) => f.name === 'Users')?.id, options.tenantId, options.userId);
+                result = this.mapFolderDtoToFolderNode(userRoot);
+                path = await this.buildPath(result, userRoot.id);
+                break;
+            }
+            default:
+                throw new Error(`Invalid scope: ${scope}`);
+        }
         return { path, result };
     }
     /**
-     * Gets a specific folder by ID.
-     * Root for path is resolved from current session (security: only scope is used).
+     * Gets a specific folder by ID
      */
-    async getFolder(scope, folderId) {
+    async getFolder(scope, folderId, options) {
         if (!folderId) {
             throw new Error('Folder ID is required');
         }
@@ -2392,7 +4807,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             throw new Error('Folder not found');
         }
         const result = this.mapFolderDtoToFolderNode(folder);
-        const path = await this.buildPath(result, (await this.getRoot(scope)).result.id);
+        const path = await this.buildPath(result, (await this.getRoot(scope, options)).result.id);
         return { path, result };
     }
     /**
@@ -2405,14 +4820,12 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
         const userRef = { id: userId, type: 'user' };
         const folderToCreate = {
             ...data,
-            title: data.title,
-            childrenCount: 0,
             created: { at: now, user: userRef },
             updated: { at: now, user: userRef },
             isSystem: false,
             isHidden: false,
             isDeleted: false,
-            size: data.size ?? 0,
+            size: 0,
         };
         const createdFolder = (await this.folderService.insertOne(folderToCreate));
         let folder;
@@ -2636,15 +5049,12 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             // Extract needed properties without id
             const { id, ...fileDataWithoutId } = originalFile;
             // Prepare file for copy by downloading from storage and converting to blob source
-            const fileListItem = await this.prepareFileForCopy(originalFile.fileInfo, newName);
-            if (!fileListItem) {
-                throw new Error('Could not prepare file for copy');
-            }
+            const fileListItem = await this.prepareFileForCopy(originalFile.fileId, newName);
             const fileData = {
                 ...fileDataWithoutId,
                 name: newName,
                 title: newName,
-                fileInfo: fileListItem,
+                fileId: fileListItem,
             };
             // Create the new file
             return await this.createFile(fileData);
@@ -2660,7 +5070,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             const { id, ...folderDataWithoutId } = originalFolder;
             const folderData = {
                 ...folderDataWithoutId,
-                title: newName,
+                name: newName,
             };
             // Create the new folder
             return await this.createFolder(folderData);
@@ -2673,7 +5083,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
      * Moves a node to another location
      */
     async moveTo(options) {
-        const comp = (await import('./acorex-modules-document-management-drive-choose.component-BOeZ9mpL.mjs')).AXMDocumentDriveChooseComponent;
+        const comp = (await import('./acorex-modules-document-management-drive-choose.component-ovwhHP2n.mjs')).AXMDocumentDriveChooseComponent;
         const popup = await this.popupService.open(comp, {
             title: `Choose ${options.browseMode == 'file' ? 'File' : 'Folder'}`,
             data: {
@@ -2706,7 +5116,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
      * Copies a node to another location
      */
     async copyTo(options) {
-        const comp = (await import('./acorex-modules-document-management-drive-choose.component-BOeZ9mpL.mjs')).AXMDocumentDriveChooseComponent;
+        const comp = (await import('./acorex-modules-document-management-drive-choose.component-ovwhHP2n.mjs')).AXMDocumentDriveChooseComponent;
         const popup = await this.popupService.open(comp, {
             title: `Choose ${options.browseMode == 'file' ? 'File' : 'Folder'}`,
             data: {
@@ -2721,7 +5131,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             if (selectedFolder) {
                 if (options.node.type === 'folder') {
                     await this.createFolder({
-                        title: options.node.name,
+                        name: options.node.name,
                         parentId: selectedFolder.id,
                         color: '#ffffff',
                         size: options.node.size,
@@ -2735,15 +5145,13 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
                         throw new Error(`File with ID ${options.node.id} not found`);
                     }
                     // Prepare file for copy by downloading from storage and converting to blob source
-                    const fileListItem = await this.prepareFileForCopy(originalFile.fileInfo, options.node.name);
-                    if (!fileListItem) {
-                        throw new Error('Could not prepare file for copy');
-                    }
+                    const fileListItem = await this.prepareFileForCopy(originalFile.fileId, options.node.name);
                     await this.createFile({
                         title: options.node.name,
                         name: options.node.name,
                         parentId: selectedFolder.id,
-                        fileInfo: fileListItem,
+                        fileId: fileListItem,
+                        size: originalFile.size ?? options.node.size ?? 0,
                         documentType: options.node.documentTypes[0],
                         status: 'Draft',
                     });
@@ -2761,29 +5169,27 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
     //#endregion
     //#region ----   Search Operations   ----
     /**
-     * Searches for folders by term within a scope.
-     * Root is resolved from current session when folderId is not provided.
+     * Searches for folders by term within a scope
      */
     async searchFolders(searchTerm, scope, options) {
         const { result: rootNode } = options?.folderId
-            ? await this.getFolder(scope, options.folderId)
-            : await this.getRoot(scope);
+            ? await this.getFolder(scope, options.folderId, options)
+            : await this.getRoot(scope, options);
         const folders = await this.documentManagementService.searchFolders(searchTerm, rootNode.id);
         return folders.map((folder) => this.mapFolderDtoToFolderNode(folder));
     }
     /**
-     * Searches for files by term within a scope.
-     * Root is resolved from current session when folderId is not provided.
+     * Searches for files by term within a scope
      */
     async searchFiles(searchTerm, scope, options) {
         const { result: rootNode } = options?.folderId
-            ? await this.getFolder(scope, options.folderId)
-            : await this.getRoot(scope);
+            ? await this.getFolder(scope, options.folderId, options)
+            : await this.getRoot(scope, options);
         const files = await this.documentManagementService.searchFiles(searchTerm, rootNode.id);
         return files.map((file) => this.mapFileToNode(file));
     }
     /**
-     * Searches for both files and folders by term within a scope.
+     * Searches for both files and folders by term within a scope
      */
     async searchNodes(searchTerm, scope, options) {
         const [folders, files] = await Promise.all([
@@ -2991,7 +5397,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
                 const selected = Array.isArray(form.documentTypes) ? form.documentTypes : [];
                 const selectedTypes = selected.map((v) => typeof v === 'object' ? v : items.find((it) => it.name === v) || { name: v, title: v, id: v });
                 await this.updateFolder(node.id, {
-                    title: form.title ?? form.name,
+                    name: form.name,
                     description: form.description,
                     inherit: form.inherit,
                     documentTypes: selectedTypes,
@@ -3015,12 +5421,12 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             .dialog((dialog) => {
             dialog
                 .setTitle('@document-management:actions.create-folder')
-                .setContext({ title: '', description: '', inherit: 'None', documentTypes: [], color: '#FFFFFF' })
+                .setContext({ name: '', description: '', inherit: 'None', documentTypes: [], color: '#FFFFFF' })
                 .content((flex) => {
                 flex
                     .setDirection('column')
-                    .formField('@general:terms.common.title', (field) => {
-                    field.path('title');
+                    .formField('@general:terms.common.name', (field) => {
+                    field.path('name');
                     field.textBox({ validations: [{ rule: 'required' }] });
                 })
                     .formField('@general:terms.common.description', (field) => {
@@ -3064,22 +5470,16 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
                     return null;
                 }
                 const form = context;
-                try {
-                    const folder = await this.createFolder({
-                        title: form.title,
-                        color: form.color,
-                        parentId,
-                        description: form.description,
-                        documentTypes: form.documentTypes,
-                        size: 0,
-                        inherit: form.inherit,
-                    });
-                    return folder;
-                }
-                catch (err) {
-                    console.error('[showCreateFolderDialog] createFolder failed', err);
-                    throw err;
-                }
+                const folder = await this.createFolder({
+                    name: form.name,
+                    color: form.color,
+                    parentId,
+                    description: form.description,
+                    documentTypes: form.documentTypes,
+                    size: 0,
+                    inherit: form.inherit,
+                });
+                return folder;
             });
         })
             .show();
@@ -3120,7 +5520,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
                 dialogRef.setLoading(true);
                 try {
                     if (node.type === 'folder') {
-                        return await this.updateFolder(node.id, { title: formData.name });
+                        return await this.updateFolder(node.id, { name: formData.name });
                     }
                     await this.updateFileName(node, formData.name);
                     return await this.updateFile(node.id, { name: formData.name });
@@ -3149,7 +5549,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
      * Shows choose file dialog
      */
     async showChooseFileDialog(scope) {
-        const comp = (await import('./acorex-modules-document-management-drive-choose.component-BOeZ9mpL.mjs')).AXMDocumentDriveChooseComponent;
+        const comp = (await import('./acorex-modules-document-management-drive-choose.component-ovwhHP2n.mjs')).AXMDocumentDriveChooseComponent;
         const result = await this.popupService.open(comp, {
             title: await this.translate.translateAsync('@document-management:actions.choose-from-drive'),
             data: {
@@ -3171,7 +5571,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             if (!item.name || item.type !== 'file')
                 return false;
             const ext = item.name.split('.').pop()?.toLowerCase();
-            return ext && AXMDocumentManagerServiceImpl.GALLERY_EXTENSIONS.includes(ext);
+            return ext && AXMDocumentManagerService.GALLERY_EXTENSIONS.includes(ext);
         });
     }
     /**
@@ -3179,7 +5579,7 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
      */
     async showFileViewerPopup(node, options) {
         const isVirtualFolder = node.parentId === 'virtual';
-        const parentFolderName = isVirtualFolder ? 'Virtual' : (await this.folderService.getOne(node.parentId)).title;
+        const parentFolderName = isVirtualFolder ? 'Virtual' : (await this.folderService.getOne(node.parentId)).name;
         const documents = isVirtualFolder
             ? (options?.folderVirtualFiles ?? [])
             : ((await this.folderService.getOne(node.parentId)).documents ?? []);
@@ -3188,19 +5588,16 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             if (!item.name)
                 return false;
             const ext = item.name.split('.').pop()?.toLowerCase();
-            return ext && AXMDocumentManagerServiceImpl.GALLERY_EXTENSIONS.includes(ext);
+            return ext && AXMDocumentManagerService.GALLERY_EXTENSIONS.includes(ext);
         });
         // Convert documents to AXPFileListItem[] format for the gallery widget
-        const fileListItems = filteredDocuments.map((doc) => {
-            const fileInfo = doc.fileInfo ?? doc.fileId;
-            return {
-                id: doc.id ?? '',
-                name: doc.name,
-                size: fileInfo?.size ?? 0,
-                status: 'attached',
-                source: fileInfo?.source,
-            };
-        });
+        const fileListItems = filteredDocuments.map((doc) => ({
+            id: doc.id ?? '',
+            name: doc.name,
+            size: doc.size,
+            status: 'attached',
+            source: doc.fileId?.source,
+        }));
         // Calculate start index
         const startIndex = isVirtualFolder
             ? (options?.folderVirtualFiles?.findIndex((f) => f.id === node.id) ?? 0)
@@ -3228,43 +5625,71 @@ class AXMDocumentManagerServiceImpl extends AXMDocumentManagerService {
             return node;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerServiceImpl, decorators: [{
-            type: Injectable
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }] });
 //#endregion
 //#region ----   Scoped Drive Service   ----
 /**
- * Scoped drive service for specific platform scopes.
- * Backend resolves tenant/user from request context (client sends only scope).
+ * Scoped drive service for specific platform scopes
  */
 class ScopedDriveService {
     //#region ----   Constructor   ----
-    constructor(parent, scope) {
+    constructor(parent, scope, options) {
         this.parent = parent;
         this.scope = scope;
+        this.options = options;
+        this.validateScopeOptions();
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validates the scope options are appropriate for the selected scope
+     */
+    validateScopeOptions() {
+        switch (this.scope) {
+            case AXPPlatformScope.Tenant:
+                if (!this.options?.tenantId) {
+                    throw new Error('Tenant ID is required for tenant scope');
+                }
+                break;
+            case AXPPlatformScope.User:
+                if (!this.options?.tenantId || !this.options?.userId) {
+                    throw new Error('Both Tenant ID and User ID are required for user scope');
+                }
+                break;
+        }
     }
     //#endregion
     //#region ----   Scoped Operations   ----
     /**
-     * Gets root folder for this scope (tenant/user from session).
+     * Gets root folder for this scope
      */
     async getRoot() {
-        return this.parent.getRoot(this.scope);
+        return this.parent.getRoot(this.scope, this.options);
     }
     /**
-     * Gets folder for this scope.
+     * Gets folder for this scope
      */
     async getFolder(folderId) {
-        return this.parent.getFolder(this.scope, folderId);
+        return this.parent.getFolder(this.scope, folderId, this.options);
     }
     /**
-     * Creates folder in this scope. Backend sets tenant/user from request context.
+     * Creates folder in this scope
      */
     async createFolder(data) {
-        return this.parent.createFolder(data);
+        const folderData = {
+            ...data,
+            tenantId: this.options?.tenantId,
+            userId: this.options?.userId,
+        };
+        return this.parent.createFolder(folderData);
     }
     /**
      * Updates folder in this scope
@@ -3287,108 +5712,33 @@ class ScopedDriveService {
     /**
      * Searches folders in this scope
      */
-    async searchFolders(searchTerm, options) {
-        return this.parent.searchFolders(searchTerm, this.scope, options);
+    async searchFolders(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchFolders(searchTerm, this.scope, this.options);
     }
     /**
      * Searches files in this scope
      */
-    async searchFiles(searchTerm, options) {
-        return this.parent.searchFiles(searchTerm, this.scope, options);
+    async searchFiles(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchFiles(searchTerm, this.scope, this.options);
     }
     /**
      * Searches nodes in this scope
      */
-    async searchNodes(searchTerm, options) {
-        return this.parent.searchNodes(searchTerm, this.scope, options);
+    async searchNodes(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchNodes(searchTerm, this.scope, this.options);
     }
     /**
      * Creates a copy of a node in this scope
      */
     async copy(node) {
+        this.validateScopeOptions();
         return this.parent.copy(node);
     }
 }
 
-//#region ---- Imports ----
-//#endregion
-/**
- * File gallery popup component that displays files using the gallery widget.
- * This component replaces the old file-viewer-popup and uses the same
- * gallery widget pattern as test8.
- */
-class AXMFileGalleryPopupComponent extends AXBasePageComponent {
-    constructor() {
-        super(...arguments);
-        //#region ---- Class Properties ----
-        /** File list items received from popup data */
-        this.files = signal([], ...(ngDevMode ? [{ debugName: "files" }] : []));
-        /** Starting index for the media viewer */
-        this.startIndex = 0;
-        /** Widget context for the gallery */
-        this.context = signal({}, ...(ngDevMode ? [{ debugName: "context" }] : []));
-        //#endregion
-        //#region ---- Computed Properties ----
-        /**
-         * Gallery widget node configuration
-         */
-        this.galleryNode = computed(() => ({
-            type: 'gallery',
-            path: 'galleryFiles',
-            defaultValue: this.files(),
-            options: {
-                thumbnail: true,
-                header: true,
-                fileInfo: true,
-                fullScreenButton: true,
-                allowUpload: false,
-                height: '100%',
-            },
-        }), ...(ngDevMode ? [{ debugName: "galleryNode" }] : []));
-    }
-    //#endregion
-    //#region ---- UI Handlers ----
-    /**
-     * Close the popup
-     */
-    onClose() {
-        this.close();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFileGalleryPopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: AXMFileGalleryPopupComponent, isStandalone: true, selector: "axm-file-gallery-popup", usesInheritance: true, ngImport: i0, template: `
-    <ax-content>
-      <axp-widgets-container class="ax-block ax-h-full" [context]="context()">
-        <ng-container axp-widget-renderer [node]="galleryNode()" [mode]="'edit'"></ng-container>
-      </axp-widgets-container>
-    </ax-content>
-    <ax-footer>
-      <ax-suffix>
-        <ax-button [text]="'close'" (click)="onClose()" />
-      </ax-suffix>
-    </ax-footer>
-  `, isInline: true, styles: [":host{display:block;height:100%}ax-content{height:calc(100% - 60px)}\n"], dependencies: [{ kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: i6.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i6.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged", "onLoad"], exportAs: ["widgetRenderer"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMFileGalleryPopupComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axm-file-gallery-popup', template: `
-    <ax-content>
-      <axp-widgets-container class="ax-block ax-h-full" [context]="context()">
-        <ng-container axp-widget-renderer [node]="galleryNode()" [mode]="'edit'"></ng-container>
-      </axp-widgets-container>
-    </ax-content>
-    <ax-footer>
-      <ax-suffix>
-        <ax-button [text]="'close'" (click)="onClose()" />
-      </ax-suffix>
-    </ax-footer>
-  `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [AXDecoratorModule, AXButtonModule, AXPWidgetCoreModule], styles: [":host{display:block;height:100%}ax-content{height:calc(100% - 60px)}\n"] }]
-        }] });
-
-var fileGalleryPopup_component = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMFileGalleryPopupComponent: AXMFileGalleryPopupComponent
-});
-
 var AXPDocumentExplorerSettings;
 (function (AXPDocumentExplorerSettings) {
     AXPDocumentExplorerSettings["ViewMode"] = "DocumentManagement:Setting:DocumentExplorer.Layout.ViewMode";
@@ -3457,7 +5807,7 @@ const AXPDocumentExplorerViewModel = signalStore({ providedIn: 'root' }, withSta
     isMultiSelect: computed(() => store.selectionMode() === 'multiple'),
     selectedNode: computed(() => store.selectedNodes()[0] ?? null),
     isDetailPanelOpen: computed(() => store.detailPanel()),
-})), withMethods((store, fileTypeService = inject(AXPFileTypeProviderService), driveService = inject(AXMDocumentManagerService), settingsService = inject(AXPSettingsService), translateService = inject(AXTranslationService), lockService = inject(AXPLockService)) => ({
+})), withMethods((store, fileTypeService = inject(AXPFileTypeProviderService), documentTypeService = inject(AXMDocumentTypeService), driveService = inject(AXMDocumentManagerService), settingsService = inject(AXPSettingsService), sessionService = inject(AXPSessionService), translateService = inject(AXTranslationService), lockService = inject(AXPLockService)) => ({
     async initialize(options) {
         // Load file types
         const fileTypes = await fileTypeService.items();
@@ -3484,7 +5834,10 @@ const AXPDocumentExplorerViewModel = signalStore({ providedIn: 'root' }, withSta
         patchState(store, { loadingFolderId: folderId, isLoading: true });
         await new Promise((resolve) => setTimeout(resolve, 100));
         try {
-            const node = await driveService.getFolder(store.scope(), folderId);
+            const node = await driveService.getFolder(store.scope(), folderId, {
+                tenantId: sessionService.tenant?.id,
+                userId: sessionService.user?.id,
+            });
             // Sort with direction
             const sortField = store.sortField();
             const sortDirection = store.sortDirection();
@@ -3938,30 +6291,29 @@ const AXPDocumentExplorerViewModel = signalStore({ providedIn: 'root' }, withSta
             },
         ];
         // Manage versions (only if document type has versioning enabled)
-        //  const docType = node.documentTypes?.[0];
-        //TODO handle versioning
-        // if (docType?.enableVersioning) {
-        //   menuItems.push({
-        //     name: 'manage-versions',
-        //     text: await trans('menus.context.manage-versions'),
-        //     icon: 'fa-light fa-clock-rotate-left',
-        //     items: [
-        //       {
-        //         name: 'upload-new-version',
-        //         text: await trans('menus.context.upload-new-version'),
-        //         icon: 'fa-light fa-file-circle-plus',
-        //         data: node,
-        //       },
-        //       {
-        //         name: 'show-version-history',
-        //         text: await trans('menus.context.show-version-history'),
-        //         icon: 'fa-light fa-timeline',
-        //         data: node,
-        //       },
-        //     ],
-        //     break: true,
-        //   });
-        // }
+        const docType = node.documentTypes?.[0];
+        if (docType?.enableVersioning) {
+            menuItems.push({
+                name: 'manage-versions',
+                text: await trans('menus.context.manage-versions'),
+                icon: 'fa-light fa-clock-rotate-left',
+                items: [
+                    {
+                        name: 'upload-new-version',
+                        text: await trans('menus.context.upload-new-version'),
+                        icon: 'fa-light fa-file-circle-plus',
+                        data: node,
+                    },
+                    {
+                        name: 'show-version-history',
+                        text: await trans('menus.context.show-version-history'),
+                        icon: 'fa-light fa-timeline',
+                        data: node,
+                    },
+                ],
+                break: true,
+            });
+        }
         // Information submenu items
         const infoSubItems = [
             {
@@ -4801,15 +7153,14 @@ const attachmentsPlugin = {
     },
 };
 
-function getDocumentMetaDataForm(item) {
+/** Extract metadata for server (metaDataForm) from widget item (meta or metaDataForm). */
+function getMetaDataFormForServer(item) {
     if (item?.meta?.metaDataForm != null)
         return item.meta.metaDataForm;
     if (item?.metaDataForm != null)
         return item.metaDataForm;
-    if (item?.meta != null && typeof item.meta === 'object' && !Array.isArray(item.meta)) {
-        const m = item.meta;
-        return m['metaDataForm'] ?? m;
-    }
+    if (item?.meta != null && typeof item.meta === 'object' && !Array.isArray(item.meta))
+        return item.meta;
     return undefined;
 }
 /** Resolve list of attachment field names from entity extensions.attachments. */
@@ -4858,7 +7209,7 @@ const attachmentsUploadMiddleware = {
                 pendingByField[field] = [];
                 const normalized = [];
                 for (const item of list) {
-                    const metaDataForm = getDocumentMetaDataForm(item);
+                    const metaDataForm = getMetaDataFormForServer(item);
                     if (item?.source?.kind === 'blob' && item.source.value instanceof Blob) {
                         const blob = item.source.value;
                         const name = item.name || `file-${Date.now()}`;
@@ -4913,7 +7264,7 @@ const attachmentsUploadMiddleware = {
                 continue;
             const finalRefs = (ctx.data[field] ?? []).filter((x) => x.status !== 'pending_upload');
             for (const { fileItem, blob } of pending) {
-                const metaDataForm = fileItem.metaDataForm ?? getDocumentMetaDataForm(fileItem);
+                const metaDataForm = fileItem.metaDataForm ?? getMetaDataFormForServer(fileItem);
                 try {
                     const info = await storage.save({
                         file: blob,
@@ -4974,17 +7325,6 @@ const attachmentsUploadMiddleware = {
     },
 };
 
-function getFileIdFromFileInfo(fileInfo) {
-    if (fileInfo == null)
-        return undefined;
-    if (typeof fileInfo === 'string')
-        return fileInfo;
-    if (fileInfo.source?.kind === 'fileId' && typeof fileInfo.source.value === 'string')
-        return fileInfo.source.value;
-    if (typeof fileInfo.id === 'string')
-        return fileInfo.id;
-    return undefined;
-}
 //#region ---- Plugin Guard Utilities ----
 /**
  * Check if the 'document' plugin is active (enabled and not excluded) in the payload.
@@ -5082,11 +7422,6 @@ const DocumentFileUploaderActionsByTypeProvider = {
                     });
                     if (files.length === 0)
                         return;
-                    const documentType = {
-                        id: docType?.id ?? '',
-                        name: typeName,
-                        title: docType?.title ?? typeName,
-                    };
                     const fileItems = files.map((file) => ({
                         id: AXPDataGenerator.uuid(),
                         name: file.name,
@@ -5094,7 +7429,7 @@ const DocumentFileUploaderActionsByTypeProvider = {
                         type: file.type,
                         status: 'attached',
                         source: { kind: 'blob', value: file },
-                        meta: { documentType },
+                        __documentTypeName: typeName,
                     }));
                     if (hasMeta) {
                         const result = await documentDialogService.openAttachmentDialogWithoutSave('Document Type Choose File', {
@@ -5103,15 +7438,8 @@ const DocumentFileUploaderActionsByTypeProvider = {
                         });
                         if (result.data?.cancel != null && !result.data.cancel && result.data?.files) {
                             result.data.files.forEach((f, i) => {
-                                if (fileItems[i]) {
-                                    const meta = {
-                                        ...fileItems[i].meta,
-                                        documentType,
-                                        metaDataForm: f?.metaDataForm,
-                                    };
-                                    set$1(fileItems[i], 'meta', meta);
-                                    set$1(fileItems[i], 'metaDataForm', f?.metaDataForm);
-                                }
+                                if (fileItems[i])
+                                    set(fileItems[i], 'metaDataForm', f?.metaDataForm);
                             });
                         }
                         else if (result.data?.cancel) {
@@ -5133,18 +7461,13 @@ const DocumentFileUploaderBeforeFilesAddedProvider = {
     priority: 0,
     async execute(payload) {
         const opts = getDocumentPluginOptions(payload);
-        const firstMeta = payload.newFiles[0]?.meta;
-        const docTypeName = firstMeta?.documentType?.name ?? opts?.docTypeName;
+        const docTypeName = payload.newFiles[0]?.__documentTypeName ??
+            opts?.docTypeName;
         if (!docTypeName)
             return payload;
         const injector = inject(Injector);
         const documentManagementService = injector.get(AXPDocumentManagementService);
         const docType = await documentManagementService.getDocumentTypeByName(docTypeName);
-        const documentType = {
-            id: docType?.id ?? '',
-            name: docType?.name ?? docTypeName,
-            title: docType?.title ?? docTypeName,
-        };
         const documentDialogService = injector.get(AXMDocumentDialogService);
         const result = await documentDialogService.openAttachmentDialogWithoutSave('Document Type Choose File', {
             documentType: docType,
@@ -5152,14 +7475,7 @@ const DocumentFileUploaderBeforeFilesAddedProvider = {
         });
         if (result.data?.cancel != null && !result.data.cancel && result.data?.files) {
             payload.newFiles.forEach((file, i) => {
-                const metaDataForm = result.data?.files?.[i]?.metaDataForm;
-                const meta = {
-                    ...file.meta,
-                    documentType,
-                    metaDataForm,
-                };
-                set$1(file, 'meta', meta);
-                set$1(file, 'metaDataForm', metaDataForm);
+                set(file, 'metaDataForm', result.data?.files?.[i]?.metaDataForm);
             });
         }
         return payload;
@@ -5170,10 +7486,9 @@ const DocumentFileUploaderEditDialogAfterFormProvider = {
     key: 'file-uploader.edit-dialog.groups.after-form',
     priority: 0,
     async execute(payload) {
-        const fileMeta = payload.file.meta;
-        const metaObj = (fileMeta?.metaDataForm ?? payload.file.metaDataForm);
+        const metaObj = payload.file?.metaDataForm;
         const opts = getDocumentPluginOptions(payload);
-        const docTypeName = fileMeta?.documentType?.name ?? opts?.docTypeName;
+        const docTypeName = payload.file?.__documentTypeName ?? opts?.docTypeName;
         const injector = inject(Injector);
         const documentManagementService = injector.get(AXPDocumentManagementService);
         const docType = docTypeName
@@ -5225,8 +7540,9 @@ const DocumentFileUploaderDownloadReferenceProvider = {
                 console.error('Document not found for reference:', payload.reference);
                 return payload;
             }
-            const fileId = getFileIdFromFileInfo(document.fileInfo);
-            if (!fileId) {
+            // Extract fileId from document
+            const fileId = typeof document.fileId === 'string' ? document.fileId : (document.fileId?.id ?? document.fileId);
+            if (!fileId || typeof fileId !== 'string') {
                 console.error('Document does not have a valid fileId:', document);
                 return payload;
             }
@@ -5285,7 +7601,13 @@ class AXMDocumentManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementModule, imports: [AXMDriveChooseModule,
             // Entity Modules
-            AXMDocumentManagementDocumentTypeEntityModule, i6.AXPWidgetCoreModule, i2$2.AXMediaViewerModule, i3$1.AXPWorkflowModule] }); }
+            AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+            AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeEntityModule,
+            AXMDocumentManagementDocumentEntityModule,
+            AXMFolderEntityModule,
+            AXMReviewEntityModule, i6.AXPWidgetCoreModule, i2$2.AXMediaViewerModule, i3$1.AXPWorkflowModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMDocumentManagementModule, providers: [
             // Module-specific providers (not part of manifest system)
             { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: attachmentsPlugin },
@@ -5337,21 +7659,15 @@ class AXMDocumentManagementModule {
                 useClass: AXMSearchCommandProvider,
                 multi: true,
             },
-            {
-                provide: AXMDocumentService,
-                useClass: AXMDocumentServiceImpl,
-            },
-            {
-                provide: AXMFolderService,
-                useClass: AXMFolderServiceImpl,
-            },
-            {
-                provide: AXMDocumentManagerService,
-                useClass: AXMDocumentManagerServiceImpl,
-            },
         ], imports: [AXMDriveChooseModule,
             // Entity Modules
+            AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+            AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
             AXMDocumentManagementDocumentTypeEntityModule,
+            AXMDocumentManagementDocumentEntityModule,
+            AXMFolderEntityModule,
+            AXMReviewEntityModule,
             AXPWidgetCoreModule.forChild({
                 widgets: [AXmFileTypeExtensionWidget],
             }),
@@ -5373,7 +7689,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                     imports: [
                         AXMDriveChooseModule,
                         // Entity Modules
+                        AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+                        AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+                        AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
                         AXMDocumentManagementDocumentTypeEntityModule,
+                        AXMDocumentManagementDocumentEntityModule,
+                        AXMFolderEntityModule,
+                        AXMReviewEntityModule,
                         AXPWidgetCoreModule.forChild({
                             widgets: [AXmFileTypeExtensionWidget],
                         }),
@@ -5441,18 +7763,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                             useClass: AXMSearchCommandProvider,
                             multi: true,
                         },
-                        {
-                            provide: AXMDocumentService,
-                            useClass: AXMDocumentServiceImpl,
-                        },
-                        {
-                            provide: AXMFolderService,
-                            useClass: AXMFolderServiceImpl,
-                        },
-                        {
-                            provide: AXMDocumentManagerService,
-                            useClass: AXMDocumentManagerServiceImpl,
-                        },
                     ],
                 }]
         }] });
@@ -5642,6 +7952,8 @@ class AXMDocumentDriveComponent extends AXPPageLayoutBaseComponent {
             this.previousFolderId = currentNode?.id ?? null;
         }
         const result = await this.driveService.searchNodes(searchValue, this.vm.scope(), {
+            tenantId: this.sessionService.tenant?.id,
+            userId: this.sessionService.user?.id,
             folderId: this.vm.isVirtual() ? (this.previousFolderId ?? undefined) : (this.vm.currentNode()?.id ?? undefined),
         });
         // Get the folder ID to use as parentId for the virtual folder
@@ -5678,7 +7990,10 @@ class AXMDocumentDriveComponent extends AXPPageLayoutBaseComponent {
         }
         else {
             // TODO: get root from tenant or user by scope
-            const root = await this.driveService.getRoot(this.vm.scope());
+            const root = await this.driveService.getRoot(this.vm.scope(), {
+                tenantId: this.sessionService.tenant?.id,
+                userId: this.sessionService.user?.id,
+            });
             if (root.result) {
                 await this.router.navigate([
                     `${this.sessionService.application?.name}/drive/${resolvePlatformScopeName(this.vm.scope())}/${root.result.id}`,
@@ -5923,5 +8238,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXMArchiveFileTypeProvider, AXMAudioFileTypeProvider, AXMCodeFileTypeProvider, AXMDocumentDriveComponent, AXMDocumentExplorerComponent, AXMDocumentFileTypeProvider, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementModule, AXMDocumentManagerService, AXMDocumentManagerServiceImpl, AXMDocumentService, AXMDocumentServiceImpl, AXMDocumentTypeService, AXMDocumentTypeServiceImpl, AXMEntityProvider, AXMFileGalleryPopupComponent, AXMFileTypeExtensionWidgetColumnComponent, AXMFileTypeExtensionWidgetDesignerComponent, AXMFileTypeExtensionWidgetEditComponent, AXMFileTypeExtensionWidgetViewComponent, AXMFileTypeModule, AXMFolderPathBreadcrumbsComponent, AXMFolderService, AXMFolderServiceImpl, AXMImageFileTypeProvider, AXMMenuProvider, AXMPermissionsKeys, AXMSearchCommandProvider, AXMSettingProvider, AXMVideoFileTypeProvider, AXPDocumentExplorerSettings, AXPDocumentExplorerViewModel, AXPDocumentManagementFeatureKeys, AXPDocumentManagementMenuKeys, AXPDocumentManagementService, AXmFileTypeExtensionWidget, RootConfig, ScopedDriveService, documentEntityFactory, documentTypeFactory, folderEntityFactory };
+export { AXMArchiveFileTypeProvider, AXMAudioFileTypeProvider, AXMCodeFileTypeProvider, AXMDocumentDriveComponent, AXMDocumentExplorerComponent, AXMDocumentFileTypeProvider, AXMDocumentManagementDocumentEntityModule, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityService, AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, AXMDocumentManagementDocumentTypeMetaValueEntityModule, AXMDocumentManagementDocumentTypeMetaValueEntityService, AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, AXMDocumentManagementDocumentTypeStatusDefinitionEntityService, AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, AXMDocumentManagementModule, AXMDocumentManagerService, AXMDocumentReletedEntityModule, AXMDocumentService, AXMDocumentServiceImpl, AXMDocumentTypeService, AXMDocumentTypeServiceImpl, AXMEntityProvider, AXMFileGalleryPopupComponent, AXMFileTypeExtensionWidgetColumnComponent, AXMFileTypeExtensionWidgetDesignerComponent, AXMFileTypeExtensionWidgetEditComponent, AXMFileTypeExtensionWidgetViewComponent, AXMFileTypeModule, AXMFolderEntityModule, AXMFolderPathBreadcrumbsComponent, AXMFolderService, AXMFolderServiceImpl, AXMImageFileTypeProvider, AXMMenuProvider, AXMPermissionsKeys, AXMReviewEntityModule, AXMReviewService, AXMReviewServiceImpl, AXMSearchCommandProvider, AXMSettingProvider, AXMVideoFileTypeProvider, AXPDocumentExplorerSettings, AXPDocumentExplorerViewModel, AXPDocumentManagementFeatureKeys, AXPDocumentManagementMenuKeys, AXPDocumentManagementService, AXmFileTypeExtensionWidget, RootConfig, ScopedDriveService, canTransition, documentFactory, documentRelatedFactory, documentTypeFactory, documentTypeMetaDefinitionfactory, documentTypeMetaValueFactory, documentTypeStatusDefinitionFactory, folderFactory, getNextStatus, reviewFactory };
 //# sourceMappingURL=acorex-modules-document-management.mjs.map