@acorex/modules 19.2.11 → 19.2.15

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

@@ -1,18 +1,33 @@
+import { AXPSessionService, AXPAuthGuard, AXP_PERMISSION_PROVIDER } from '@acorex/platform/auth';
+import { AXPSearchCommandProvider, AXPEntityQueryType, AXPEntityCommandScope, createAllQueryView, AXPFileTypeProviderService, AXP_FILE_TYPE_INFO_PROVIDER, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPEntityService, AXMEntityCrudServiceImpl, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
-import { inject, Injector, Injectable, NgModule } from '@angular/core';
-import { AXP_PERMISSION_PROVIDER } from '@acorex/platform/auth';
-import { AXPSearchCommandProvider, AXMEntityCrudServiceImpl, AXPEntityQueryType, AXPEntityCommandScope, createAllQueryView, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
-import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
-import { upperFirst, camelCase } from 'lodash-es';
+import { inject, Injector, Injectable, NgModule, Component, ChangeDetectionStrategy, signal } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import * as i6 from '@acorex/platform/layout/builder';
+import { AXPWidgetsCatalog, AXPWidgetComponent, AXPLayoutBuilderModule, AXP_WIDGETS_ADVANCE_GROUP } from '@acorex/platform/layout/builder';
+import { ROUTES } from '@angular/router';
+import { AXDataSource } from '@acorex/components/common';
+import { AXMMetaDataDefinitionService } from '@acorex/modules/platform-management';
+import { CommonModule } from '@angular/common';
+import * as i7$1 from '@acorex/components/collapse';
+import { AXCollapseModule } from '@acorex/components/collapse';
+import * as i5 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i7 from '@acorex/components/form';
+import { AXFormModule } from '@acorex/components/form';
+import * as i4 from '@acorex/components/label';
+import { AXLabelModule } from '@acorex/components/label';
+import * as i1 from '@acorex/components/select-box';
+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 { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/widgets';
 
 const config = {
     i18n: 'document-management',
-    documentEntity: 'Document',
-    documentTypeEntity: 'DocumentType',
-    documentTypeMetaDefinitionEntity: 'DocumentTypeMetaDefinition',
-    documentTypeMetaValueEntity: 'DocumentTypeMetaValue',
-    documentTypeStatusDefinitionEntity: 'DocumentTypeStatusDefinition',
 };
 const RootConfig = {
     config,
@@ -23,17 +38,23 @@ const RootConfig = {
         icon: 'fa-light fa-file-invoice',
     },
     entities: {
+        folder: {
+            name: 'Folder',
+            title: `t("folder", { scope: "${config.i18n}" })`,
+            titlePlural: `t("folderPlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-folder',
+        },
         document: {
             name: 'Document',
             title: `t("document", { scope: "${config.i18n}" })`,
             titlePlural: `t("documentPlural", { scope: "${config.i18n}" })`,
-            icon: 'fa-light fa-document',
+            icon: 'fa-light fa-file',
         },
         documentType: {
             name: 'DocumentType',
             title: `t("documentType", { scope: "${config.i18n}" })`,
             titlePlural: `t("documentTypePlural", { scope: "${config.i18n}" })`,
-            icon: 'fa-light fa-document',
+            icon: 'fa-light fa-books',
         },
         documentTypeMetaDefinition: {
             name: 'documentTypeMeta',
@@ -56,29 +77,6 @@ const RootConfig = {
     },
 };
 
-class AXMMenuProvider {
-    constructor() {
-        this.entityService = inject(AXPEntityService);
-    }
-    async provide(context) {
-        context.addItems([
-            {
-                priority: 9001,
-                text: RootConfig.module.title,
-                icon: RootConfig.module.icon,
-                children: [
-                    {
-                        text: RootConfig.entities.documentType.title,
-                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.documentType.name),
-                        icon: RootConfig.entities.documentType.icon,
-                        priority: 1,
-                    },
-                ],
-            },
-        ]);
-    }
-}
-
 class AXMEntityProvider {
     constructor() {
         this.injector = inject(Injector);
@@ -94,9 +92,11 @@ class AXMEntityProvider {
         if (moduleName == RootConfig.module.name) {
             switch (entityName) {
                 case RootConfig.entities.document.name:
-                    return (await Promise.resolve().then(function () { return index$1; })).documentFactory(this.injector);
+                    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 index; })).folderFactory(this.injector);
             }
         }
         return null;
@@ -108,6 +108,53 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        //
+        context.addItems([
+            {
+                priority: 9001,
+                text: RootConfig.module.title,
+                icon: RootConfig.module.icon,
+                children: [
+                    {
+                        text: RootConfig.entities.documentType.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.documentType.name),
+                        icon: RootConfig.entities.documentType.icon,
+                        priority: 2
+                    },
+                    {
+                        text: RootConfig.entities.document.titlePlural,
+                        path: `${this.sessionService.application?.name}/drive/company`,
+                        icon: RootConfig.entities.document.icon,
+                        priority: 1
+                    }
+                ]
+            }
+        ]);
+        //
+        context.find('edit-profile').insert([
+            {
+                name: 'my-notifications',
+                text: `t('my-drive.title', {scope: "${RootConfig.config.i18n}"})`,
+                icon: 'fa-light fa-folder-open',
+                path: `${this.sessionService.application?.name}/drive/my`,
+                data: {
+                    scope: 'user'
+                },
+            },
+        ], 'after');
+    }
+}
+
 class AXMPermissionProvider {
     async provide(context) {
         // context.addPermissions([
@@ -120,6 +167,25 @@ class AXMPermissionProvider {
     }
 }
 
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+        // {
+        //   group: 'command',
+        //  title: 'New Form Template',
+        //  icon: RootConfig.entities.template.icon,
+        //  description: 'Create a new form template for designing reusable forms.', // Added description
+        //  commands: {
+        //    'create-entity': {
+        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
+        //    },
+        //  },
+        // }
+        ];
+    }
+}
+
 class AXMSettingProvider {
     async provide(context) {
         // context
@@ -148,40 +214,25 @@ class AXMSettingProvider {
     }
 }
 
-class AXMSearchCommandProvider extends AXPSearchCommandProvider {
-    constructor() {
-        super(...arguments);
-        this.commands = [
-        // {
-        //   group: 'command',
-        //  title: 'New Form Template',
-        //  icon: RootConfig.entities.template.icon,
-        //  description: 'Create a new form template for designing reusable forms.', // Added description
-        //  commands: {
-        //    'create-entity': {
-        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
-        //    },
-        //  },
-        // }
-        ];
-    }
-}
-
-class AXMDocumentManagementDocumentEntityService extends AXMEntityCrudServiceImpl {
+class AXMDocumentService extends AXMEntityCrudServiceImpl {
 }
-class AXMDocumentManagementDocumentEntityServiceImpl extends AXMDocumentManagementDocumentEntityService {
+class AXMDocumentServiceImpl extends AXMDocumentService {
     constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.document}`);
+        super(`${RootConfig.module.name}.${RootConfig.entities.document.name}`);
+    }
+    async getPath(_) {
+        throw new Error('Not implemented');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentServiceImpl, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
 async function documentFactory(injector) {
-    const dataService = injector.get(AXMDocumentManagementDocumentEntityService);
+    const dataService = injector.get(AXMDocumentService);
+    const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.document.name,
@@ -240,6 +291,72 @@ async function documentFactory(injector) {
                     },
                 ],
             },
+            {
+                name: 'type',
+                title: 't("type", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.documentType.name}`,
+                            expose: 'type',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'metaData',
+                title: 't("metaData", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.metaData,
+                        options: {
+                            listMeta: ` {{context.eval("type.meta")}} `,
+                        },
+                        triggers: [
+                            {
+                                event: `{{ events.context("type") }}`,
+                                action: `{{ console.log(context.eval("type")); }}`,
+                            },
+                        ],
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'file',
+                title: `t("file", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.file,
+                        options: {
+                            maxFileSize: ` {{context.eval("type.maxSize")}} `,
+                            multiple: ` {{context.eval("type.multiple")}} `,
+                            accept: ` {{context.eval("type.multiple")}} `,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
         ],
         columns: [{ name: 'name' }, { name: 'title' }],
         commands: {
@@ -303,6 +420,36 @@ async function documentFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 update: {
@@ -332,6 +479,36 @@ async function documentFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 single: {
@@ -369,6 +546,36 @@ async function documentFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
@@ -403,16 +610,7 @@ async function documentFactory(injector) {
                             scope: AXPEntityCommandScope.Individual,
                         },
                     ],
-                    views: [
-                        {
-                            name: 'all',
-                            title: 't("allItem", { scope: "common" })',
-                            fixed: true,
-                            columns: [],
-                            conditions: [],
-                            sorts: [],
-                        },
-                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
                 },
             },
         },
@@ -425,8 +623,8 @@ class AXMDocumentManagementDocumentEntityModule {
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, providers: [
             {
-                provide: AXMDocumentManagementDocumentEntityService,
-                useClass: AXMDocumentManagementDocumentEntityServiceImpl,
+                provide: AXMDocumentService,
+                useClass: AXMDocumentServiceImpl,
             },
         ] }); }
 }
@@ -438,209 +636,48 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                     declarations: [],
                     providers: [
                         {
-                            provide: AXMDocumentManagementDocumentEntityService,
-                            useClass: AXMDocumentManagementDocumentEntityServiceImpl,
+                            provide: AXMDocumentService,
+                            useClass: AXMDocumentServiceImpl,
                         },
                     ],
                 }]
         }] });
 
-var index$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMDocumentManagementDocumentEntityModule: AXMDocumentManagementDocumentEntityModule,
-    AXMDocumentManagementDocumentEntityService: AXMDocumentManagementDocumentEntityService,
-    AXMDocumentManagementDocumentEntityServiceImpl: AXMDocumentManagementDocumentEntityServiceImpl,
-    documentFactory: documentFactory
-});
+class AXMDocumentManagementDocumentTypeEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeEntityServiceImpl extends AXMDocumentManagementDocumentTypeEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentType.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
-const AXM_COLUMN_DEF_WIDGET = [
-    {
-        type: 'grid-row-layout',
-        mode: 'view',
-        children: [
-            {
-                type: 'grid-item-layout',
-                mode: 'view',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: 'text-editor',
-                        mode: 'edit',
-                        path: 'name',
-                        options: {
-                            placeholder: 'Name',
-                            defaultValue: 'test',
-                        },
-                    },
-                ],
+async function documentTypeFactory(injector) {
+    const dataService = injector.get(AXMDocumentManagementDocumentTypeEntityService);
+    const metaDefinitionService = injector.get(AXMMetaDataDefinitionService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.documentType.name,
+        source: '',
+        title: RootConfig.entities.documentType.title,
+        formats: {
+            individual: RootConfig.entities.documentType.title,
+            plural: RootConfig.entities.documentType.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
             },
-            {
-                type: 'grid-item-layout',
-                mode: 'view',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: 'text-editor',
-                        mode: 'edit',
-                        path: 'title',
-                        options: {
-                            placeholder: 'Title',
-                        },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 3 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'select-editor',
-                        mode: 'edit',
-                        path: 'type',
-                        options: {
-                            ruleValidation: {
-                                rule: true,
-                            },
-                            placeholder: 'Type',
-                            valueField: 'name',
-                            textField: 'title',
-                            dataSource: Object.entries(AXPWidgetsCatalog).map(([key, value]) => {
-                                return {
-                                    title: upperFirst(camelCase(key)),
-                                    name: value,
-                                };
-                            }),
-                            direction: 'horizontal',
-                            multiple: false,
-                        },
-                    },
-                ],
-            },
-            {
-                type: 'grid-item-layout',
-                options: { colSpan: 2 },
-                mode: 'view',
-                children: [
-                    {
-                        type: 'checkbox-editor',
-                        mode: 'edit',
-                        path: 'isRequire',
-                    },
-                ],
-            },
-        ],
-    },
-];
-// export const AXM_COLUMN_DEF_WIDGET = [
-//   {
-//     type: 'grid-row-layout',
-//     //  name: 'grid-row-layout1',
-//     mode: 'view',
-//     path: '',
-//     children: [
-//       {
-//         type: 'grid-item-layout',
-//         mode: 'view',
-//         //   path: '',
-//         options: { colSpan: 4 },
-//         // name: 'grid-item-layout1',
-//         children: [
-//           {
-//             type: 'text-editor',
-//             //name: 'text-editor1',
-//             mode: 'edit',
-//             path: 'name',
-//             options: {
-//               placeholder: 'Name',
-//               defaultValue: 'test',
-//             },
-//           },
-//         ],
-//       },
-//       {
-//         type: 'grid-item-layout',
-//         mode: 'view',
-//         //   path: '',
-//         options: { colSpan: 4 },
-//         //name: 'grid-item-layout2',
-//         children: [
-//           {
-//             type: 'text-editor',
-//             // name: 'text-editor2',
-//             mode: 'edit',
-//             path: 'title',
-//             options: {
-//               placeholder: 'Title',
-//             },
-//           },
-//         ],
-//       },
-//       {
-//         type: 'grid-item-layout',
-//         options: { colSpan: 4 },
-//         mode: 'view',
-//         // path: '',
-//         //  name: 'grid-item-layout3',
-//         children: [
-//           {
-//             type: 'select-editor',
-//             //name: 'select-editor1',
-//             mode: 'edit',
-//             path: 'type',
-//             options: {
-//               placeholder: 'Type',
-//               valueField: 'name',
-//               textField: 'title',
-//               dataSource: [
-//                 { title: 'text', name: AXPWidgetsCatalog.text },
-//                 { title: 'Check Box', name: AXPWidgetsCatalog.checkbox },
-//                 { title: 'Gallery', name: AXPWidgetsCatalog.gallery },
-//               ],
-//               direction: 'horizontal',
-//               multiple: false,
-//             },
-//           },
-//         ],
-//       },
-//     ],
-//   },
-// ];
-
-class AXMDocumentManagementDocumentTypeEntityService extends AXMEntityCrudServiceImpl {
-}
-class AXMDocumentManagementDocumentTypeEntityServiceImpl extends AXMDocumentManagementDocumentTypeEntityService {
-    constructor() {
-        super(`${RootConfig.module.name}.${RootConfig.entities.documentType}`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-async function documentTypeFactory(injector) {
-    const dataService = injector.get(AXMDocumentManagementDocumentTypeEntityService);
-    const i18n = RootConfig.config.i18n;
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.document.name,
-        source: '',
-        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: [
+        },
+        relatedEntities: [],
+        groups: [
             {
                 id: 'section',
-                title: RootConfig.entities.document.title,
+                title: RootConfig.entities.documentType.title,
             },
         ],
         properties: [
@@ -681,33 +718,88 @@ async function documentTypeFactory(injector) {
                     },
                 ],
             },
+            {
+                name: 'maxSize',
+                title: `t("maxSize", { scope: "${i18n}" })`,
+                groupId: 'section',
+                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: `t("isEncrypted", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                    },
+                },
+            },
             {
                 name: 'meta',
                 title: `t("meta", { scope: "${i18n}" })`,
                 groupId: 'section',
                 schema: {
-                    defaultValue: [
-                        {
-                            name: 'name',
-                            title: 'Name',
-                            type: {
-                                title: 'Text',
-                                name: 'text-editor',
-                            },
-                        },
-                        {
-                            name: 'title',
-                            title: 'Title',
-                            type: {
-                                title: 'Text',
-                                name: 'text-editor',
-                            },
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'id',
+                            textField: 'title',
+                            //defaultValue: AXMFormTemplateTypes.Form,
+                            dataSource: new AXDataSource({
+                                load: async (_) => {
+                                    const metaData = await metaDefinitionService.query();
+                                    return metaData;
+                                },
+                                pageSize: 100,
+                            }),
+                            multiple: true,
                         },
-                    ],
+                    },
+                },
+            },
+            {
+                name: 'type',
+                title: `t("type", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
                     dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.repeaterLayout,
-                        children: AXM_COLUMN_DEF_WIDGET,
+                        type: AXPWidgetsCatalog.fileTypeExtension,
+                        options: {},
                     },
                 },
             },
@@ -734,7 +826,9 @@ async function documentTypeFactory(injector) {
         queries: {
             byKey: {
                 execute: async (id) => {
-                    return await dataService.getOne(id);
+                    const x = await dataService.getOne(id);
+                    console.log(x);
+                    return x;
                 },
                 type: AXPEntityQueryType.Single,
             },
@@ -774,6 +868,26 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                         {
                             name: 'meta',
                             layout: {
@@ -784,6 +898,16 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 update: {
@@ -813,6 +937,26 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                         {
                             name: 'meta',
                             layout: {
@@ -823,6 +967,16 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 single: {
@@ -860,6 +1014,26 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                         {
                             name: 'meta',
                             layout: {
@@ -870,6 +1044,16 @@ async function documentTypeFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
@@ -937,14 +1121,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMDocumentManagementDocumentTypeEntityModule: AXMDocumentManagementDocumentTypeEntityModule,
-    AXMDocumentManagementDocumentTypeEntityService: AXMDocumentManagementDocumentTypeEntityService,
-    AXMDocumentManagementDocumentTypeEntityServiceImpl: AXMDocumentManagementDocumentTypeEntityServiceImpl,
-    documentTypeFactory: documentTypeFactory
-});
-
 class AXMDocumentManagementDocumentTypeMetaDefinitionEntityService extends AXMEntityCrudServiceImpl {
 }
 class AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl extends AXMDocumentManagementDocumentTypeMetaDefinitionEntityService {
@@ -1752,44 +1928,1130 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
-class AXMDocumentManagementModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, imports: [AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, AXMDocumentManagementDocumentTypeMetaValueEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementDocumentEntityModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, providers: [
-            {
-                provide: AXP_MENU_PROVIDER,
-                useClass: AXMMenuProvider,
-                multi: true,
-            },
-            {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMEntityProvider,
-                multi: true,
+class AXMFolderService extends AXMEntityCrudServiceImpl {
+}
+class AXMFolderServiceImpl extends AXMFolderService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.folder.name}`);
+    }
+    async getPath(_) {
+        throw new Error('Not implemented');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFolderServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFolderServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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,
+        source: '',
+        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: [
             {
-                provide: AXP_SETTING_DEFINITION_PROVIDER,
-                useClass: AXMSettingProvider,
-                multi: true,
+                id: 'section',
+                title: RootConfig.entities.folder.title,
             },
+        ],
+        properties: [
             {
-                provide: AXP_SEARCH_PROVIDER,
-                useClass: AXMSearchCommandProvider,
-                multi: true,
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                provide: AXP_PERMISSION_PROVIDER,
-                useClass: AXMPermissionProvider,
-                multi: true,
-            },
-        ], imports: [AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, AXMDocumentManagementDocumentTypeMetaValueEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementDocumentEntityModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, AXMDocumentManagementDocumentTypeMetaValueEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementDocumentEntityModule,],
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                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({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                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: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentManagementDocumentEntityModule: AXMDocumentManagementDocumentEntityModule,
+    AXMDocumentManagementDocumentTypeEntityModule: AXMDocumentManagementDocumentTypeEntityModule,
+    AXMDocumentManagementDocumentTypeEntityService: AXMDocumentManagementDocumentTypeEntityService,
+    AXMDocumentManagementDocumentTypeEntityServiceImpl: AXMDocumentManagementDocumentTypeEntityServiceImpl,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityService: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+    AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+    AXMDocumentManagementDocumentTypeMetaValueEntityModule: AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+    AXMDocumentManagementDocumentTypeMetaValueEntityService: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+    AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityService: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+    AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+    AXMDocumentService: AXMDocumentService,
+    AXMDocumentServiceImpl: AXMDocumentServiceImpl,
+    AXMFolderService: AXMFolderService,
+    AXMFolderServiceImpl: AXMFolderServiceImpl,
+    documentFactory: documentFactory,
+    documentTypeFactory: documentTypeFactory,
+    documentTypeMetaDefinitionfactory: documentTypeMetaDefinitionfactory,
+    documentTypeMetaValueFactory: documentTypeMetaValueFactory,
+    documentTypeStatusDefinitionFactory: documentTypeStatusDefinitionFactory,
+    folderFactory: folderFactory
+});
+
+class AXMImageFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'image',
+                title: 'Image',
+                icon: 'fa-light fa-image ax-text-purple-500',
+                extensions: [
+                    {
+                        name: 'jpg',
+                        title: 'JPEG',
+                        icon: 'fa-light fa-image ax-text-purple-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'png',
+                        title: 'PNG',
+                        icon: 'fa-light fa-image ax-text-purple-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'gif',
+                        title: 'GIF',
+                        icon: 'fa-light fa-image ax-text-purple-500',
+                        meta: [
+                            {
+                                name: 'duration',
+                                title: 'Duration',
+                                interface: async () => {
+                                    return {
+                                        type: AXPWidgetsCatalog.text,
+                                        options: {
+                                            validations: [
+                                                {
+                                                    rule: "required"
+                                                }
+                                            ]
+                                        },
+                                        path: 'gift.duration',
+                                    };
+                                },
+                            },
+                        ],
+                    },
+                ],
+                meta: [
+                    {
+                        name: 'width',
+                        title: 'Width',
+                        interface: async () => {
+                            return {
+                                type: AXPWidgetsCatalog.text,
+                                options: {
+                                    validations: [
+                                        {
+                                            rule: "required"
+                                        }
+                                    ]
+                                },
+                                path: 'image.width',
+                            };
+                        },
+                    },
+                    {
+                        name: 'height',
+                        title: 'Height',
+                        interface: async () => {
+                            return {
+                                type: AXPWidgetsCatalog.text,
+                                options: {},
+                                path: 'image.height',
+                            };
+                        },
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMVideoFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'video',
+                title: 'Video',
+                icon: 'fa-light fa-video ax-text-red-500',
+                extensions: [
+                    {
+                        name: 'mp4',
+                        title: 'MP4',
+                        icon: 'fa-light fa-video ax-text-red-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'avi',
+                        title: 'AVI',
+                        icon: 'fa-light fa-video ax-text-red-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'mkv',
+                        title: 'MKV',
+                        icon: 'fa-light fa-video ax-text-red-500',
+                        meta: [],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMDocumentFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'document',
+                title: 'Document',
+                icon: 'fa-light fa-file-lines ax-text-blue-600',
+                extensions: [
+                    {
+                        name: 'pdf',
+                        title: 'PDF',
+                        icon: 'fa-light fa-file-pdf ax-text-red-600',
+                        meta: [],
+                    },
+                    {
+                        name: 'doc',
+                        title: 'Word',
+                        icon: 'fa-light fa-file-word ax-text-blue-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'docx',
+                        title: 'Word',
+                        icon: 'fa-light fa-file-word ax-text-blue-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'xls',
+                        title: 'Excel',
+                        icon: 'fa-light fa-file-excel ax-text-green-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'xlsx',
+                        title: 'Excel',
+                        icon: 'fa-light fa-file-excel ax-text-green-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'ppt',
+                        title: 'PowerPoint',
+                        icon: 'fa-light fa-file-powerpoint ax-text-orange-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'pptx',
+                        title: 'PowerPoint',
+                        icon: 'fa-light fa-file-powerpoint ax-text-orange-700',
+                        meta: [],
+                    },
+                    {
+                        name: 'txt',
+                        title: 'Text',
+                        icon: 'fa-light fa-file-lines ax-text-blue-600',
+                        meta: [],
+                    },
+                    {
+                        name: 'rtf',
+                        title: 'Rich Text',
+                        icon: 'fa-light fa-file-lines ax-text-blue-600',
+                        meta: [],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMAudioFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'audio',
+                title: 'Audio',
+                icon: 'fa-light fa-file-audio ax-text-green-500',
+                extensions: [
+                    {
+                        name: 'mp3',
+                        title: 'MP3',
+                        icon: 'fa-light fa-file-audio ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'wav',
+                        title: 'WAV',
+                        icon: 'fa-light fa-file-audio ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'ogg',
+                        title: 'OGG',
+                        icon: 'fa-light fa-file-audio ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'm4a',
+                        title: 'M4A',
+                        icon: 'fa-light fa-file-audio ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'flac',
+                        title: 'FLAC',
+                        icon: 'fa-light fa-file-audio ax-text-green-500',
+                        meta: [],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMArchiveFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'archive',
+                title: 'Archive',
+                icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                extensions: [
+                    {
+                        name: 'zip',
+                        title: 'ZIP',
+                        icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'rar',
+                        title: 'RAR',
+                        icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                        meta: [],
+                    },
+                    {
+                        name: '7z',
+                        title: '7-Zip',
+                        icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'tar',
+                        title: 'TAR',
+                        icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'gz',
+                        title: 'GZIP',
+                        icon: 'fa-light fa-file-zipper ax-text-orange-500',
+                        meta: [],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMCodeFileTypeProvider {
+    async items() {
+        return [
+            {
+                name: 'code',
+                title: 'Code',
+                icon: 'fa-light fa-file-code ax-text-blue-500',
+                extensions: [
+                    {
+                        name: 'js',
+                        title: 'JavaScript',
+                        icon: 'fa-light fa-file-code ax-text-yellow-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'ts',
+                        title: 'TypeScript',
+                        icon: 'fa-light fa-file-code ax-text-blue-600',
+                        meta: [],
+                    },
+                    {
+                        name: 'html',
+                        title: 'HTML',
+                        icon: 'fa-light fa-file-code ax-text-orange-600',
+                        meta: [],
+                    },
+                    {
+                        name: 'css',
+                        title: 'CSS',
+                        icon: 'fa-light fa-file-code ax-text-pink-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'json',
+                        title: 'JSON',
+                        icon: 'fa-light fa-file-code ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'xml',
+                        title: 'XML',
+                        icon: 'fa-light fa-file-code ax-text-green-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'py',
+                        title: 'Python',
+                        icon: 'fa-light fa-file-code ax-text-yellow-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'java',
+                        title: 'Java',
+                        icon: 'fa-light fa-file-code ax-text-red-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'cpp',
+                        title: 'C++',
+                        icon: 'fa-light fa-file-code ax-text-blue-500',
+                        meta: [],
+                    },
+                    {
+                        name: 'cs',
+                        title: 'C#',
+                        icon: 'fa-light fa-file-code ax-text-blue-500',
+                        meta: [],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMFileTypeExtensionWidgetColumnComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMFileTypeExtensionWidgetColumnComponent, isStandalone: true, selector: "ng-component", inputs: { rawValue: "rawValue" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: ['rawValue'],
+                }]
+        }] });
+
+var fileTypeExtensionColumn_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMFileTypeExtensionWidgetColumnComponent: AXMFileTypeExtensionWidgetColumnComponent
+});
+
+class AXMFileTypeExtensionWidgetDesignerComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetDesignerComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMFileTypeExtensionWidgetDesignerComponent, isStandalone: true, selector: "ng-component", inputs: { rawValue: "rawValue" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetDesignerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: ['rawValue'],
+                }]
+        }] });
+
+// @if(allowSearch()) {
+//     <ax-search-box><ax-clear-button></ax-clear-button></ax-search-box>
+//     } @if(hasClearButton()) {
+//     <ax-clear-button></ax-clear-button>
+//     } @for (validation of validationRules(); track $index) {
+//     <ax-validation-rule
+//       [rule]="validation.rule"
+//       [message]="validation.options?.message"
+//       [options]="validation.options"
+//     ></ax-validation-rule>
+//     } @for (validation of validationRules(); track $index) {
+//     <ax-validation-rule
+//       [rule]="validation.rule"
+//       [message]="validation.options?.message"
+//       [options]="validation.options"
+//     ></ax-validation-rule>
+class AXMFileTypeExtensionWidgetEditComponent extends AXPWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.fileTypeService = inject(AXPFileTypeProviderService);
+        this.dataSource = new AXDataSource({
+            load: async (_) => {
+                try {
+                    const res = await this.fileTypeService.items();
+                    const types = res
+                        .map((item) => {
+                        const { meta, extensions, ...rest } = item;
+                        return extensions.map((ext) => {
+                            const { meta, ...extRest } = ext;
+                            return {
+                                ...rest,
+                                ...extRest,
+                                name: `${item.name}.${ext.name}`,
+                                title: `${item.title}/${ext.title}`,
+                            };
+                        });
+                    })
+                        .flat();
+                    return {
+                        items: types,
+                        total: types.length,
+                    };
+                }
+                catch (e) {
+                    console.log(e);
+                }
+                return {
+                    items: [],
+                    total: 0,
+                };
+            },
+            pageSize: 100,
+        });
+        this.selectedItems = signal(this.getValue()?.selectedItems ?? []);
+        this.context = signal(this.getValue()?.context ?? {});
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.selectedItems.set(this.getValue()?.selectedItems ?? []);
+        this.context.set(this.getValue()?.context ?? {});
+    }
+    outputs() {
+        return ['selectedItems', 'context'];
+    }
+    handleOnContextChange(e) {
+        this.context.set(e.data);
+        this.setValue({ ...this.getValue(), context: e.data });
+    }
+    async handleValueChange(e) {
+        const selectItems = e.component.selectedItems;
+        this.setValue({ ...this.getValue(), selectedItems: selectItems });
+        const result = {};
+        for (const item of selectItems) {
+            const type = item.name.split('.')[0];
+            const ext = item.name.split('.')[1];
+            var fileType = await this.fileTypeService.get(type);
+            if (fileType != undefined) {
+                const extension = fileType.extensions.find((extension) => extension.name == ext) || { name: ext, title: '' };
+                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);
+                        }
+                    }
+                }
+                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);
+                        }
+                    }
+                }
+                if (result[type]) {
+                    result[type] = {
+                        ...fileType,
+                        extensions: [...result[type].extensions, extension],
+                    };
+                }
+                else {
+                    result[type] = {
+                        ...fileType,
+                        extensions: [extension],
+                    };
+                }
+            }
+        }
+        this.selectedItems.set(Object.values(result));
+    }
+    getNode(meta) {
+        return get(meta, '__node__');
+    }
+    filedIsRequired(meta) {
+        const node = get(meta, '__node__');
+        if (node && node.options && node.options.validations) {
+            return node.options.validations.some((validation) => validation.rule === 'required');
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXMFileTypeExtensionWidgetEditComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <div>
+      <ax-select-box
+        #dd
+        [dataSource]="dataSource"
+        valueField="name"
+        textField="title"
+        [multiple]="true"
+        [ngModel]="getValue()?.selectedItems"
+        (onValueChanged)="handleValueChange($event)"
+      >
+      </ax-select-box>
+      <div class="ax-py-3"></div>
+      <axp-widgets-container (onContextChanged)="handleOnContextChange($event)" [context]="context()">
+        @if (selectedItems().length > 0) {
+          <ax-collapse-group look="fill">
+            @for (item of selectedItems(); track item.name) {
+              <!-- File Types -->
+              <ax-collapse [caption]="item.title">
+                <div class="ax-flex ax-flex-col ax-gap-5">
+                  @if (item.meta && item.meta.length > 0) {
+                    <div class="ax-flex ax-flex-col ax-gap-2">
+                      <ax-text [textContent]="'Global Meta Data'" class="ax-font-bold ax-text-sm"></ax-text>
+                      @for (metaFile of item.meta; track metaFile.name) {
+                        <!-- File Meta Data -->
+                        <ax-form-field>
+                        <ax-label [required]="filedIsRequired(metaFile)">{{ metaFile.title }}</ax-label>
+                        <ng-container axp-widget-renderer [node]="getNode(metaFile)" [mode]="'edit'"></ng-container>
+                      </ax-form-field>
+                      }
+                    </div>
+                  }
+                  @if (item.extensions && item.extensions.length > 0) {
+                    <div class="ax-flex ax-flex-col ax-gap-3">
+                      @for (ext of item.extensions; track ext.name) {
+                        <!-- Extensions -->
+                        @if (ext.meta && ext.meta.length > 0) {
+                          <ax-text [textContent]="ext.title" class="ax-font-bold ax-text-sm"></ax-text>
+                          <div class="ax-flex ax-flex-col ax-gap-2">
+                            @for (extMeta of ext.meta; track $index) {
+                              <!-- Extension Meta Data -->
+                              <ax-form-field>
+                                <ax-label [required]="filedIsRequired(extMeta)">{{ extMeta.title }}</ax-label>
+                                <ng-container axp-widget-renderer [node]="getNode(extMeta)"
+                                              [mode]="'edit'"></ng-container>
+                              </ax-form-field>
+                            }
+                          </div>
+                        }
+                        <!-- End Extension Meta Data -->
+                      }
+                    </div>
+                    <!-- End Extensions -->
+                  }
+                </div>
+              </ax-collapse>
+            }
+            <!-- End File Types -->
+          </ax-collapse-group>
+        }
+      </axp-widgets-container>
+    </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXSelectBoxModule }, { kind: "component", type: i1.AXSelectBoxComponent, selector: "ax-select-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "minValue", "maxValue", "value", "state", "name", "id", "type", "look", "multiple", "valueField", "textField", "disabledField", "textTemplate", "selectedItems", "dataSource", "minRecordsForSearch", "caption", "itemTemplate", "selectedTemplate", "emptyTemplate", "loadingTemplate", "dropdownWidth", "searchBoxAutoFocus"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXFormModule }, { kind: "component", type: i7.AXFormFieldComponent, selector: "ax-form-field", inputs: ["labelMode"] }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i4.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i5.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: AXPLayoutBuilderModule }, { 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"], exportAs: ["widgetRenderer"] }, { kind: "ngmodule", type: AXCollapseModule }, { kind: "component", type: i7$1.AXCollapseComponent, selector: "ax-collapse", inputs: ["disabled", "look", "isCollapsed", "showHeader", "caption", "icon", "isLoading", "headerTemplate"], outputs: ["onClick", "isCollapsedChange"] }, { kind: "component", type: i7$1.AXCollapseGroupComponent, selector: "ax-collapse-group", inputs: ["look", "accordion", "activeIndex"], outputs: ["accordionChange", "activeIndexChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div>
+      <ax-select-box
+        #dd
+        [dataSource]="dataSource"
+        valueField="name"
+        textField="title"
+        [multiple]="true"
+        [ngModel]="getValue()?.selectedItems"
+        (onValueChanged)="handleValueChange($event)"
+      >
+      </ax-select-box>
+      <div class="ax-py-3"></div>
+      <axp-widgets-container (onContextChanged)="handleOnContextChange($event)" [context]="context()">
+        @if (selectedItems().length > 0) {
+          <ax-collapse-group look="fill">
+            @for (item of selectedItems(); track item.name) {
+              <!-- File Types -->
+              <ax-collapse [caption]="item.title">
+                <div class="ax-flex ax-flex-col ax-gap-5">
+                  @if (item.meta && item.meta.length > 0) {
+                    <div class="ax-flex ax-flex-col ax-gap-2">
+                      <ax-text [textContent]="'Global Meta Data'" class="ax-font-bold ax-text-sm"></ax-text>
+                      @for (metaFile of item.meta; track metaFile.name) {
+                        <!-- File Meta Data -->
+                        <ax-form-field>
+                        <ax-label [required]="filedIsRequired(metaFile)">{{ metaFile.title }}</ax-label>
+                        <ng-container axp-widget-renderer [node]="getNode(metaFile)" [mode]="'edit'"></ng-container>
+                      </ax-form-field>
+                      }
+                    </div>
+                  }
+                  @if (item.extensions && item.extensions.length > 0) {
+                    <div class="ax-flex ax-flex-col ax-gap-3">
+                      @for (ext of item.extensions; track ext.name) {
+                        <!-- Extensions -->
+                        @if (ext.meta && ext.meta.length > 0) {
+                          <ax-text [textContent]="ext.title" class="ax-font-bold ax-text-sm"></ax-text>
+                          <div class="ax-flex ax-flex-col ax-gap-2">
+                            @for (extMeta of ext.meta; track $index) {
+                              <!-- Extension Meta Data -->
+                              <ax-form-field>
+                                <ax-label [required]="filedIsRequired(extMeta)">{{ extMeta.title }}</ax-label>
+                                <ng-container axp-widget-renderer [node]="getNode(extMeta)"
+                                              [mode]="'edit'"></ng-container>
+                              </ax-form-field>
+                            }
+                          </div>
+                        }
+                        <!-- End Extension Meta Data -->
+                      }
+                    </div>
+                    <!-- End Extensions -->
+                  }
+                </div>
+              </ax-collapse>
+            }
+            <!-- End File Types -->
+          </ax-collapse-group>
+        }
+      </axp-widgets-container>
+    </div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, AXSelectBoxModule, FormsModule, AXFormModule, AXLabelModule, AXDecoratorModule, AXPLayoutBuilderModule, AXCollapseModule],
+                    inputs: [],
+                }]
+        }] });
+
+var fileTypeExtensionEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMFileTypeExtensionWidgetEditComponent: AXMFileTypeExtensionWidgetEditComponent
+});
+
+class AXMFileTypeExtensionWidgetViewComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMFileTypeExtensionWidgetViewComponent, isStandalone: true, selector: "ng-component", inputs: { rawValue: "rawValue" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeExtensionWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: ['rawValue'],
+                }]
+        }] });
+
+var fileTypeExtensionView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMFileTypeExtensionWidgetViewComponent: AXMFileTypeExtensionWidgetViewComponent
+});
+
+const AXmFileTypeExtensionWidget = {
+    name: 'file-type-extension',
+    title: 'File Type Extension',
+    description: 'Uploads and manages files',
+    icon: 'fa-solid fa-files',
+    group: AXP_WIDGETS_ADVANCE_GROUP,
+    type: 'editor',
+    properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return fileTypeExtensionView_component; }).then((c) => c.AXMFileTypeExtensionWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return fileTypeExtensionEdit_component; }).then((c) => c.AXMFileTypeExtensionWidgetEditComponent),
+        },
+        // filter: {
+        //   component: () => import('./file-type-extension-filter.component').then((c) => c.AXPFileBoxWidgetFilterComponent),
+        // },
+        column: {
+            component: () => Promise.resolve().then(function () { return fileTypeExtensionColumn_component; }).then((c) => c.AXMFileTypeExtensionWidgetColumnComponent),
+        },
+        // print: {
+        //   component: () => import('./file-type-extension-print.component').then((c) => c.AXPFileBoxWidgetPrintComponent),
+        // },
+        designer: {
+            component: () => Promise.resolve().then(function () { return fileTypeExtensionEdit_component; }).then((c) => c.AXMFileTypeExtensionWidgetEditComponent),
+        },
+    },
+};
+
+class AXMFileTypeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeModule, providers: [
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMImageFileTypeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMVideoFileTypeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMDocumentFileTypeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMAudioFileTypeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMCodeFileTypeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                useClass: AXMArchiveFileTypeProvider,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileTypeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMImageFileTypeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMVideoFileTypeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMDocumentFileTypeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMAudioFileTypeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMCodeFileTypeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FILE_TYPE_INFO_PROVIDER,
+                            useClass: AXMArchiveFileTypeProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+function routesFacory() {
+    const config = inject(AXP_ENTITY_CONFIG_TOKEN);
+    const routes = [
+        {
+            path: ':app/drive/:scope',
+            component: config.viewers.root(),
+            canActivate: [AXPAuthGuard],
+            data: { reuse: true },
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-modules-document-management-drive.component-bjnFFaLS.mjs').then((c) => c.AXMDocumentDriveComponent),
+                },
+                {
+                    path: ':id',
+                    loadComponent: () => import('./acorex-modules-document-management-drive.component-bjnFFaLS.mjs').then((c) => c.AXMDocumentDriveComponent),
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMDocumentManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, imports: [AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+            AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeEntityModule,
+            AXMDocumentManagementDocumentEntityModule, i6.AXPLayoutBuilderModule, AXMFileTypeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, providers: [
+            {
+                provide: AXMFolderService,
+                useClass: AXMFolderServiceImpl,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMSearchCommandProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_PERMISSION_PROVIDER,
+                useClass: AXMPermissionProvider,
+                multi: true,
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFacory,
+            },
+        ], imports: [AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+            AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+            AXMDocumentManagementDocumentTypeEntityModule,
+            AXMDocumentManagementDocumentEntityModule,
+            AXPLayoutBuilderModule.forChild({
+                widgets: [AXmFileTypeExtensionWidget],
+            }),
+            AXMFileTypeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule,
+                        AXMDocumentManagementDocumentTypeMetaValueEntityModule,
+                        AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule,
+                        AXMDocumentManagementDocumentTypeEntityModule,
+                        AXMDocumentManagementDocumentEntityModule,
+                        AXPLayoutBuilderModule.forChild({
+                            widgets: [AXmFileTypeExtensionWidget],
+                        }),
+                        AXMFileTypeModule,
+                    ],
                     exports: [],
-                    declarations: [],
                     providers: [
+                        {
+                            provide: AXMFolderService,
+                            useClass: AXMFolderServiceImpl,
+                        },
                         {
                             provide: AXP_MENU_PROVIDER,
                             useClass: AXMMenuProvider,
@@ -1815,15 +3077,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXMPermissionProvider,
                             multi: true,
                         },
-                    ]
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFacory,
+                        },
+                    ],
                 }]
         }] });
 
-//export * from './lib/pages';
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMDocumentManagementModule, AXMEntityProvider, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, RootConfig };
+export { AXMDocumentManagementDocumentEntityModule, AXMDocumentManagementDocumentTypeEntityModule, AXMDocumentManagementDocumentTypeEntityService, AXMDocumentManagementDocumentTypeEntityServiceImpl, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, AXMDocumentManagementDocumentTypeMetaDefinitionEntityService, AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, AXMDocumentManagementDocumentTypeMetaValueEntityModule, AXMDocumentManagementDocumentTypeMetaValueEntityService, AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, AXMDocumentManagementDocumentTypeStatusDefinitionEntityService, AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, AXMDocumentManagementModule, AXMDocumentService, AXMDocumentServiceImpl, AXMEntityProvider, AXMFolderService, AXMFolderServiceImpl, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, RootConfig, documentFactory, documentTypeFactory, documentTypeMetaDefinitionfactory, documentTypeMetaValueFactory, documentTypeStatusDefinitionFactory, folderFactory };
 //# sourceMappingURL=acorex-modules-document-management.mjs.map