@acorex/modules 19.2.15 → 19.2.17-next.0

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

@@ -0,0 +1,4092 @@
+import { AXPSessionService, AXPAuthGuard, AXP_PERMISSION_PROVIDER } from '@acorex/platform/auth';
+import { AXPSearchCommandProvider, AXPEntityQueryType, AXPEntityCommandScope, createAllQueryView, AXPFileTypeProviderService, AXP_FILE_TYPE_INFO_PROVIDER, AXPSettingScope, AXPSettingService, 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, Component, ChangeDetectionStrategy, signal, computed, viewChild, effect } from '@angular/core';
+import { firstValueFrom, Subject } from 'rxjs';
+import * as i6 from '@acorex/platform/layout/builder';
+import { AXPWidgetsCatalog, AXPWidgetComponent, AXPLayoutBuilderModule, AXP_WIDGETS_ADVANCE_GROUP, AXP_WIDGETS_EDITOR_GROUP } from '@acorex/platform/layout/builder';
+import { RouterModule, ROUTES } from '@angular/router';
+import { AXDataSource } from '@acorex/components/common';
+import { AXMMetaDataDefinitionService } from '@acorex/modules/platform-management';
+import * as i1$1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i7$1 from '@acorex/components/collapse';
+import { AXCollapseModule } from '@acorex/components/collapse';
+import * as i5$1 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 i5 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';
+import { AXLoadingModule } from '@acorex/components/loading';
+import * as i4 from '@acorex/components/menu';
+import { AXMenuModule } from '@acorex/components/menu';
+import { AXDateTimeModule } from '@acorex/core/date-time';
+import * as i3 from '@acorex/core/format';
+import { AXFormatModule } from '@acorex/core/format';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPDataGenerator, AXPElementDataDirective } from '@acorex/platform/core';
+import { get as get$1 } from 'lodash-es';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXPopupService } from '@acorex/components/popup';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+
+const config = {
+    i18n: 'document-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        module: 'DocumentManagement',
+        name: 'DocumentManagement',
+        title: `t('documentManagement', {scope:"${config.i18n}"})`,
+        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-file',
+        },
+        documentType: {
+            name: 'DocumentType',
+            title: `t("documentType", { scope: "${config.i18n}" })`,
+            titlePlural: `t("documentTypePlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-books',
+        },
+        documentTypeMetaDefinition: {
+            name: 'documentTypeMeta',
+            title: `t("documentTypeMeta", { scope: "${config.i18n}" })`,
+            titlePlural: `t("documentTypeMetaPlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-meta',
+        },
+        documentTypeMetaValue: {
+            name: 'documentTypeMetaValue',
+            title: `t("documentTypeMetaValue", { scope: "${config.i18n}" })`,
+            titlePlural: `t("documentTypeMetaValuePlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-meta',
+        },
+        documentTypeStatus: {
+            name: 'documentTypeStatus',
+            title: `t("documentTypeStatus", { scope: "${config.i18n}" })`,
+            titlePlural: `t("documentTypeStatusPlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-status',
+        },
+    },
+};
+
+class AXMEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            switch (entityName) {
+                case RootConfig.entities.document.name:
+                    return (await Promise.resolve().then(function () { return index; })).documentFactory(this.injector);
+                case RootConfig.entities.documentType.name:
+                    return (await Promise.resolve().then(function () { return index; })).documentTypeFactory(this.injector);
+                case RootConfig.entities.folder.name:
+                    return (await Promise.resolve().then(function () { return index; })).folderFactory(this.injector);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMEntityProvider, decorators: [{
+            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([
+        //   {
+        //     name: 'view_templates',
+        //     title: 'Permission to view templates',
+        //     isArchived: false,
+        //   },
+        // ]);
+    }
+}
+
+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
+        //   // Add Form Template Group
+        //   .addGroup('form-template', 'Form Template', 'Settings related to form templates.', RootConfig.module.icon)
+        //   // Start Interface Section
+        //   .addSection('interface', 'UI Interface', 'Customize the user interface for forms.')
+        //   .addSetting({
+        //     key: 'history-panel',
+        //     title: 'Show History Panel',
+        //     scope: 'U',
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     widget: {
+        //       type: AXPWidgetsCatalog.toggle,
+        //     },
+        //     description: 'Enable or disable the history panel for forms.',
+        //     validationRules: [
+        //       {
+        //         rule: 'required',
+        //       },
+        //     ],
+        //   })
+        //   .endSection()
+        //   .endGroup();
+    }
+}
+
+class AXMDocumentService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentServiceImpl extends AXMDocumentService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.document.name}`);
+    }
+    async getPath(_) {
+        throw new Error('Not implemented');
+    }
+    async searchFiles(_searchTerm, _rootFolderId) {
+        throw new Error('Not implemented');
+    }
+    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: AXMDocumentServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function documentFactory(injector) {
+    const dataService = injector.get(AXMDocumentService);
+    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: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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: {
+            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,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'metaData',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'file',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    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;
+}
+
+class AXMDocumentManagementDocumentEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    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: AXMDocumentService,
+                useClass: AXMDocumentServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentService,
+                            useClass: AXMDocumentServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+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: () => [] });
+
+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,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.documentType.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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: {
+                    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.fileTypeExtension,
+                        options: {},
+                    },
+                },
+            },
+        ],
+        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) => {
+                    const x = await dataService.getOne(id);
+                    console.log(x);
+                    return x;
+                },
+                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,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'meta',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'meta',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'maxSize',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'isEncrypted',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'meta',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    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()],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMDocumentManagementDocumentTypeEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeEntityService,
+                useClass: AXMDocumentManagementDocumentTypeEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl extends AXMDocumentManagementDocumentTypeMetaDefinitionEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeMetaDefinition}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function documentTypeMetaDefinitionfactory(injector) {
+    const dataService = injector.get(AXMDocumentManagementDocumentTypeMetaDefinitionEntityService);
+    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: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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;
+}
+
+class AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+                useClass: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeMetaDefinitionEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMDocumentManagementDocumentTypeMetaValueEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl extends AXMDocumentManagementDocumentTypeMetaValueEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeMetaValue}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function documentTypeMetaValueFactory(injector) {
+    const dataService = injector.get(AXMDocumentManagementDocumentTypeMetaValueEntityService);
+    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: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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;
+}
+
+class AXMDocumentManagementDocumentTypeMetaValueEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+                useClass: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeMetaValueEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeMetaValueEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl extends AXMDocumentManagementDocumentTypeStatusDefinitionEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.documentTypeStatus}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function documentTypeStatusDefinitionFactory(injector) {
+    const dataService = injector.get(AXMDocumentManagementDocumentTypeStatusDefinitionEntityService);
+    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: [
+            {
+                id: 'section',
+                title: RootConfig.entities.document.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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;
+}
+
+class AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, providers: [
+            {
+                provide: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+                useClass: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDocumentManagementDocumentTypeStatusDefinitionEntityService,
+                            useClass: AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMFolderService extends AXMEntityCrudServiceImpl {
+}
+class AXMFolderServiceImpl extends AXMFolderService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.folder.name}`);
+    }
+    async getPath(_) {
+        throw new Error('Not implemented');
+    }
+    async searchFolders(_searchTerm, _rootFolderId) {
+        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: [
+            {
+                id: 'section',
+                title: RootConfig.entities.folder.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                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: i5.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i5$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: 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,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMDocumentAttachmentWidgetColumnComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMDocumentAttachmentWidgetColumnComponent, isStandalone: true, selector: "ng-component", 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: AXMDocumentAttachmentWidgetColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: [],
+                }]
+        }] });
+
+var documentAttachmentWidgetColumn_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentAttachmentWidgetColumnComponent: AXMDocumentAttachmentWidgetColumnComponent
+});
+
+var AXMDriveScope;
+(function (AXMDriveScope) {
+    AXMDriveScope["Platform"] = "P";
+    AXMDriveScope["Tenant"] = "T";
+    AXMDriveScope["User"] = "U";
+})(AXMDriveScope || (AXMDriveScope = {}));
+
+/**
+ * Service for handling document drive operations
+ */
+class AXMDocumentManagerService {
+    constructor() {
+        this.folderService = inject(AXMFolderService);
+        this.sessionService = inject(AXPSessionService);
+        this.documentService = inject(AXMDocumentService);
+        this.popupService = inject(AXPopupService);
+        this.dialogService = inject(AXDialogService);
+        this.scopedDriveCache = new Map();
+    }
+    scope(scope, options) {
+        const cacheKey = this.getScopeCacheKey(scope, options);
+        if (!this.scopedDriveCache.has(cacheKey)) {
+            this.scopedDriveCache.set(cacheKey, new ScopedDriveService(this, scope, options));
+        }
+        return this.scopedDriveCache.get(cacheKey);
+    }
+    getScopeCacheKey(scope, options) {
+        // در آینده می‌توان این را برای کش کردن بر اساس ترکیب scope و options گسترش داد
+        return scope;
+    }
+    /**
+     * Gets the platform root folder (top-level folder)
+     * @returns Root folder for the platform
+     */
+    async getPlatformRootFolder() {
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: [
+                    { field: 'parentId', operator: { type: 'isNull' } },
+                    { field: 'tenantId', operator: { type: 'isNull' } },
+                    { field: 'userId', operator: { type: 'isNull' } },
+                ],
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('Platform root folder not found');
+        }
+        return result.items[0];
+    }
+    /**
+     * Gets the tenant root folder
+     * @param rootFolderId The platform root folder ID
+     * @param tenantId The tenant ID
+     * @returns Tenant root folder
+     */
+    async getTenantRootFolder(rootFolderId, tenantId) {
+        if (!tenantId) {
+            throw new Error('Tenant ID is required');
+        }
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: [
+                    { field: 'parentId', operator: { type: 'equal' }, value: rootFolderId },
+                    { field: 'tenantId', operator: { type: 'equal' }, value: tenantId },
+                    { field: 'userId', operator: { type: 'isNull' } },
+                ],
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('Tenant root folder not found');
+        }
+        return result.items[0];
+    }
+    /**
+     * Gets the user root folder
+     * @param tenantFolderId The tenant folder ID
+     * @param tenantId The tenant ID
+     * @param userId The user ID
+     * @returns User root folder
+     */
+    async getUserRootFolder(tenantFolderId, tenantId, userId) {
+        if (!tenantId || !userId) {
+            throw new Error('Both Tenant ID and User ID are required');
+        }
+        const result = await this.folderService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                operator: null,
+                logic: 'and',
+                filters: [
+                    { field: 'parentId', operator: { type: 'equal' }, value: tenantFolderId },
+                    { field: 'tenantId', operator: { type: 'equal' }, value: tenantId },
+                    { field: 'userId', operator: { type: 'equal' }, value: userId },
+                ],
+            },
+        });
+        if (result.items.length === 0) {
+            throw new Error('User root folder not found');
+        }
+        return result.items[0];
+    }
+    mapFolderDtoToFolderNode(folder) {
+        return {
+            id: folder.id,
+            name: folder.name,
+            type: 'folder',
+            parentId: folder.parentId || null,
+            lastModified: folder.updatedAt,
+            children: [
+                ...(folder.folders?.map((child) => ({
+                    id: child.id,
+                    name: child.name,
+                    type: 'folder',
+                    parentId: child.parentId || null,
+                    lastModified: child.updatedAt,
+                    size: AXPDataGenerator.number(50, 9000000),
+                })) || []),
+                ...(folder.documents?.map((doc) => ({
+                    id: doc.id,
+                    name: doc.name,
+                    type: 'file',
+                    parentId: doc.parentId,
+                    lastModified: AXPDataGenerator.date(),
+                    size: AXPDataGenerator.number(50, 9000000),
+                })) || []),
+            ],
+        };
+    }
+    async buildPath(node) {
+        if (node.type === 'file') {
+            return (await this.documentService.getPath(node.id)).map(this.mapFolderDtoToFolderNode);
+        }
+        return (await this.folderService.getPath(node.id)).map(this.mapFolderDtoToFolderNode);
+    }
+    async findNodeById(id) {
+        const findNode = (nodes) => {
+            for (const node of nodes) {
+                if (node.id === id) {
+                    return node;
+                }
+                if (node.children) {
+                    const found = findNode(node.children);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        return findNode([(await this.getRoot(AXMDriveScope.Platform)).result]);
+    }
+    /**
+     * Gets the root folder based on the specified scope
+     * @param scope The drive scope (Platform, Tenant, User)
+     * @param options Optional parameters for tenant and user IDs
+     * @returns Root folder for the specified scope
+     */
+    async getRoot(scope, options) {
+        const rootFolder = await this.getPlatformRootFolder();
+        let result;
+        switch (scope) {
+            case AXMDriveScope.Platform:
+                result = this.mapFolderDtoToFolderNode(rootFolder);
+                break;
+            case AXMDriveScope.Tenant: {
+                if (!options?.tenantId) {
+                    throw new Error('Tenant ID is required for tenant scope');
+                }
+                const tenantRoot = await this.getTenantRootFolder(rootFolder.id, options.tenantId);
+                result = this.mapFolderDtoToFolderNode(tenantRoot);
+                break;
+            }
+            case AXMDriveScope.User: {
+                if (!options?.tenantId || !options?.userId) {
+                    throw new Error('Both Tenant ID and User ID are required for user scope');
+                }
+                const tenantFolder = await this.getTenantRootFolder(rootFolder.id, options.tenantId);
+                const userRoot = await this.getUserRootFolder(tenantFolder.id, options.tenantId, options.userId);
+                result = this.mapFolderDtoToFolderNode(userRoot);
+                break;
+            }
+            default:
+                throw new Error(`Invalid scope: ${scope}`);
+        }
+        const path = await this.buildPath(result);
+        return { path, result };
+    }
+    /**
+     * Gets a specific folder by ID
+     * @param folderId The folder ID to retrieve
+     * @returns The requested folder
+     */
+    async getFolder(folderId) {
+        if (!folderId) {
+            throw new Error('Folder ID is required');
+        }
+        const folder = await this.folderService.getOne(folderId);
+        if (!folder) {
+            throw new Error('Folder not found');
+        }
+        const result = this.mapFolderDtoToFolderNode(folder);
+        const path = await this.buildPath(result);
+        return { path, result };
+    }
+    async createFolder(data) {
+        const now = new Date();
+        const currentUser = this.sessionService.user;
+        const folderToCreate = {
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+            createdBy: currentUser?.id?.toString() ?? 'system',
+            updatedBy: currentUser?.id?.toString() ?? 'system',
+            isSystem: false,
+            isHidden: false,
+            isDeleted: false,
+        };
+        const createdFolder = await this.folderService.insertOne(folderToCreate);
+        const folder = await this.folderService.getOne(createdFolder);
+        return this.mapFolderDtoToFolderNode(folder);
+    }
+    async updateFolder(folderId, data) {
+        const currentUser = this.sessionService.user;
+        const updateData = {
+            ...data,
+            updatedBy: currentUser?.id?.toString() ?? 'system',
+            updatedAt: new Date(),
+        };
+        await this.folderService.updateOne(folderId, updateData);
+        const updatedFolder = await this.folderService.getOne(folderId);
+        return this.mapFolderDtoToFolderNode(updatedFolder);
+    }
+    async deleteFolder(folderId) {
+        await this.folderService.deleteOne(folderId);
+    }
+    async getAvailableSpace() {
+        // For now, return a fixed value of 100GB (56 * 1024 * 1024 * 1024 bytes)
+        // This should be replaced with actual storage quota logic when implemented
+        return 56 * 1024 * 1024 * 1024;
+    }
+    mapFileToNode(file) {
+        return {
+            id: file.id,
+            name: file.name,
+            type: 'file',
+            parentId: file.parentId,
+            lastModified: new Date(),
+        };
+    }
+    async createFile(data) {
+        const fileId = await this.documentService.insertOne(data);
+        const file = await this.documentService.getOne(fileId);
+        return this.mapFileToNode(file);
+    }
+    async updateFile(fileId, data) {
+        const y = await this.documentService.getOne(fileId);
+        console.log(y);
+        debugger;
+        const updatedFile = await this.documentService.updateOne(fileId, data);
+        return this.mapFileToNode(updatedFile);
+    }
+    async deleteFile(fileId) {
+        await this.documentService.deleteOne(fileId);
+    }
+    async deleteNodes(nodeIds) {
+        for (const nodeId of nodeIds) {
+            try {
+                await this.deleteFolder(nodeId);
+            }
+            catch {
+                try {
+                    await this.deleteFile(nodeId);
+                }
+                catch (error) {
+                    console.error(`Failed to delete node with id ${nodeId}:`, error);
+                }
+            }
+        }
+    }
+    async showCreateFolderDialog(parentId) {
+        const comp = (await import('./acorex-modules-document-management-create-folder-dialog.component-BnRaCq_Q.mjs')).AXMCreateFolderDialog;
+        const popup = await this.popupService.open(comp, {
+            title: 't("actions.create-folder")',
+            data: {
+                parentId,
+            },
+        });
+        return popup.data?.folder;
+    }
+    async rename(node) {
+        const comp = (await import('./acorex-modules-document-management-rename-node-dialog.component-EBf1XqU8.mjs')).AXMRenameNodeDialog;
+        const popup = await this.popupService.open(comp, {
+            title: 't("actions.rename")',
+            data: {
+                node,
+            },
+        });
+        return popup.data?.folder;
+    }
+    async showDeleteNodesDialog(nodeIds) {
+        const subject = new Subject();
+        subject.subscribe((status) => {
+            console.log(`The process has been "${status}".`);
+        });
+        const dialog = this.dialogService.open({
+            content: 'Are you sure?',
+            title: 'Delete',
+            type: 'danger',
+            buttons: [
+                {
+                    text: 'Yes',
+                    color: 'danger',
+                    onClick: async (e) => {
+                        e.handled = true;
+                        e.source.text = 'Deleting...';
+                        e.source.disabled = true;
+                        e.source.loading = true;
+                        subject.next('Started');
+                        await this.deleteNodes(nodeIds);
+                        subject.complete();
+                        dialog.close();
+                    },
+                },
+                {
+                    text: 'No',
+                    color: 'default',
+                    autofocus: true,
+                    onClick: () => {
+                        dialog.close();
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * جستجوی فولدرها با نام مشخص شده در اسکوپ
+     * @param searchTerm عبارت جستجو
+     * @param scope اسکوپ جستجو
+     * @param options گزینه‌های اضافی مانند tenantId و userId
+     */
+    async searchFolders(searchTerm, scope, options) {
+        const { result: rootNode } = await this.getRoot(scope, options);
+        const folders = await this.folderService.searchFolders(searchTerm, rootNode.id);
+        return folders.map((folder) => this.mapFolderDtoToFolderNode(folder));
+    }
+    /**
+     * جستجوی فایل‌ها با نام مشخص شده در اسکوپ
+     * @param searchTerm عبارت جستجو
+     * @param scope اسکوپ جستجو
+     * @param options گزینه‌های اضافی مانند tenantId و userId
+     */
+    async searchFiles(searchTerm, scope, options) {
+        const { result: rootNode } = await this.getRoot(scope, options);
+        const files = await this.documentService.searchFiles(searchTerm, rootNode.id);
+        return files.map((file) => this.mapFileToNode(file));
+    }
+    /**
+     * جستجوی تمام نودها (فولدرها و فایل‌ها) با نام مشخص شده در اسکوپ
+     * @param searchTerm عبارت جستجو
+     * @param scope اسکوپ جستجو
+     * @param options گزینه‌های اضافی مانند tenantId و userId
+     */
+    async searchNodes(searchTerm, scope, options) {
+        const [folders, files] = await Promise.all([
+            this.searchFolders(searchTerm, scope, options),
+            this.searchFiles(searchTerm, scope, options),
+        ]);
+        return [...folders, ...files];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+class ScopedDriveService {
+    constructor(parent, scope, options) {
+        this.parent = parent;
+        this.scope = scope;
+        this.options = options;
+        this.validateScopeOptions();
+    }
+    validateScopeOptions() {
+        switch (this.scope) {
+            case AXMDriveScope.Tenant:
+                if (!this.options?.tenantId) {
+                    throw new Error('Tenant ID is required for tenant scope');
+                }
+                break;
+            case AXMDriveScope.User:
+                if (!this.options?.tenantId || !this.options?.userId) {
+                    throw new Error('Both Tenant ID and User ID are required for user scope');
+                }
+                break;
+        }
+    }
+    async getRoot() {
+        return this.parent.getRoot(this.scope, this.options);
+    }
+    async getFolder(folderId) {
+        return this.parent.getFolder(folderId);
+    }
+    async createFolder(data) {
+        const folderData = {
+            ...data,
+            tenantId: this.options?.tenantId,
+            userId: this.options?.userId,
+        };
+        return this.parent.createFolder(folderData);
+    }
+    async updateFolder(folderId, data) {
+        return this.parent.updateFolder(folderId, data);
+    }
+    async deleteFolder(folderId) {
+        return this.parent.deleteFolder(folderId);
+    }
+    async getAvailableSpace() {
+        return this.parent.getAvailableSpace();
+    }
+    /**
+     * جستجوی فولدرها با نام مشخص شده در اسکوپ فعلی
+     * @param searchTerm عبارت جستجو
+     */
+    async searchFolders(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchFolders(searchTerm, this.scope, this.options);
+    }
+    /**
+     * جستجوی فایل‌ها با نام مشخص شده در اسکوپ فعلی
+     * @param searchTerm عبارت جستجو
+     */
+    async searchFiles(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchFiles(searchTerm, this.scope, this.options);
+    }
+    /**
+     * جستجوی تمام نودها (فولدرها و فایل‌ها) با نام مشخص شده در اسکوپ فعلی
+     * @param searchTerm عبارت جستجو
+     */
+    async searchNodes(searchTerm) {
+        this.validateScopeOptions();
+        return this.parent.searchNodes(searchTerm, this.scope, this.options);
+    }
+}
+
+var AXPDocumentExplorerSettings;
+(function (AXPDocumentExplorerSettings) {
+    AXPDocumentExplorerSettings["ViewMode"] = "document-explorer:layout:view-mode";
+    AXPDocumentExplorerSettings["SortField"] = "document-explorer:layout:sort-field";
+    AXPDocumentExplorerSettings["SortDirection"] = "document-explorer:layout:sort-direction";
+})(AXPDocumentExplorerSettings || (AXPDocumentExplorerSettings = {}));
+
+const AXPDocumentExplorerViewModel = signalStore({ providedIn: 'root' }, withState(() => ({
+    // View State
+    viewMode: 'grid',
+    isLoading: false,
+    // Navigation State
+    currentPath: [],
+    currentNode: null,
+    loadingFolderId: null,
+    navigatingFolderId: null,
+    // Sort State
+    sortField: 'name',
+    sortDirection: 'asc',
+    // Content State
+    folders: [],
+    files: [],
+    itemsCount: 0,
+    availableSpace: 0,
+    // Drive State
+    currentDrive: null,
+    // File Type State
+    fileTypes: [],
+})), withComputed((store) => ({
+    isRoot: computed(() => {
+        const node = store.currentNode();
+        return node?.id === 'root' || !node?.parentId;
+    }),
+    breadcrumb: computed(() => store.currentPath()),
+    currentFolder: computed(() => store.currentNode()),
+    currentFolderContents: computed(() => ({
+        folders: store.folders(),
+        files: store.files(),
+    })),
+    parentFolder: computed(() => {
+        const currentNode = store.currentNode();
+        return currentNode?.parentId ? store.folders().find((folder) => folder.id === currentNode.parentId) : null;
+    }),
+    isGridView: computed(() => store.viewMode() === 'grid'),
+    isListView: computed(() => store.viewMode() === 'list'),
+})), withMethods((store, fileTypeService = inject(AXPFileTypeProviderService), driveService = inject(AXMDocumentManagerService), settingService = inject(AXPSettingService)) => ({
+    async initialize(path = 'root') {
+        // Load file types
+        const fileTypes = await fileTypeService.items();
+        patchState(store, { fileTypes });
+        // Load initial settings
+        const viewMode = await settingService.get(AXPDocumentExplorerSettings.ViewMode);
+        const sortField = await settingService.get(AXPDocumentExplorerSettings.SortField);
+        const sortDirection = await settingService.get(AXPDocumentExplorerSettings.SortDirection);
+        patchState(store, {
+            viewMode: viewMode || 'grid',
+            sortField: sortField || 'name',
+            sortDirection: sortDirection || 'asc',
+        });
+    },
+    _load: async (folderId) => {
+        patchState(store, { loadingFolderId: folderId, isLoading: true });
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        try {
+            const node = await driveService.getFolder(folderId);
+            patchState(store, {
+                currentNode: node.result,
+                currentPath: node.path,
+                folders: node.result.children?.filter((item) => item.type === 'folder') || [],
+                files: node.result.children?.filter((item) => item.type === 'file') || [],
+                itemsCount: node.result.children?.length || 0,
+                availableSpace: await driveService.getAvailableSpace(),
+                loadingFolderId: null,
+                isLoading: false,
+                navigatingFolderId: null,
+            });
+        }
+        catch (error) {
+            patchState(store, {
+                loadingFolderId: null,
+                isLoading: false,
+            });
+            throw error;
+        }
+    },
+    navigateToFolder(folderId) {
+        patchState(store, { navigatingFolderId: folderId });
+    },
+    async loadFolderContents(folderId) {
+        await this._load(folderId);
+    },
+    setViewMode(mode) {
+        patchState(store, { viewMode: mode });
+        settingService.scope(AXPSettingScope.User).set(AXPDocumentExplorerSettings.ViewMode, mode);
+    },
+    setSortField(field) {
+        patchState(store, { sortField: field });
+        settingService.scope(AXPSettingScope.User).set(AXPDocumentExplorerSettings.SortField, field);
+    },
+    setSortDirection(direction) {
+        patchState(store, { sortDirection: direction });
+        settingService.scope(AXPSettingScope.User).set(AXPDocumentExplorerSettings.SortDirection, direction);
+    },
+    setDrive(scope) {
+        patchState(store, { currentDrive: scope });
+    },
+    isLoadingFolder(folderId) {
+        return store.loadingFolderId() === folderId;
+    },
+    getFileInfo(fileName) {
+        const fileTypes = store.fileTypes();
+        const extension = fileName.split('.').pop()?.toLowerCase() || '';
+        const extensions = fileTypes.flatMap((type) => type.extensions);
+        const fileType = extensions.find((e) => e.name === extension);
+        return {
+            icon: fileType?.icon || 'fa-light fa-file',
+            type: fileType?.name || 'Unknown',
+        };
+    },
+    sortItems(items) {
+        const field = store.sortField();
+        const direction = store.sortDirection();
+        return [...items].sort((a, b) => {
+            let comparison = 0;
+            switch (field) {
+                case 'name':
+                    comparison = a.name.localeCompare(b.name);
+                    break;
+                case 'modified':
+                    const aDate = a.lastModified ? new Date(a.lastModified) : new Date(0);
+                    const bDate = b.lastModified ? new Date(b.lastModified) : new Date(0);
+                    comparison = aDate.getTime() - bDate.getTime();
+                    break;
+                case 'size':
+                    comparison = (a.size || 0) - (b.size || 0);
+                    break;
+            }
+            return direction === 'asc' ? comparison : -comparison;
+        });
+    },
+    async refresh() {
+        const currentFolder = store.currentNode();
+        if (currentFolder) {
+            await this._load(currentFolder.id);
+        }
+    },
+})));
+
+class AXMDocumentExplorerComponent {
+    constructor() {
+        this.vm = inject(AXPDocumentExplorerViewModel);
+        this.contextMenu = viewChild('itemsContextMenu');
+        this.rootContextMenu = viewChild('rootContextMenu');
+        this.driveService = inject(AXMDocumentManagerService);
+        this.translateService = inject(AXTranslationService);
+        this.#effect = effect(() => {
+            const navigatingFolderId = this.vm.loadingFolderId();
+            if (!navigatingFolderId) {
+                setTimeout(() => {
+                    this.contextMenu()?.refresh();
+                    this.rootContextMenu()?.refresh();
+                }, 100);
+            }
+        });
+    }
+    #effect;
+    handleNavigateToFolder(folderId) {
+        this.vm.navigateToFolder(folderId);
+    }
+    // Context Menu Handlers
+    async handleContextMenuOnOpening(e) {
+        const node = get$1(e.targetElement, '__data__');
+        if (!node) {
+            return;
+        }
+        const allowedAddItems = node.type === 'folder';
+        const allowDelete = true;
+        const isPasteAvailable = true;
+        const allowPaste = false;
+        const open = node.type == 'file'
+            ? [
+                {
+                    name: 'open-file',
+                    text: 'Open',
+                    icon: this.vm.getFileInfo(node.name).icon,
+                    data: node,
+                },
+                {
+                    name: 'download',
+                    text: 'Download',
+                    icon: 'fa-light fa-download',
+                    data: node,
+                },
+            ]
+            : [
+                {
+                    name: 'open-folder',
+                    text: 'Open',
+                    icon: 'fa-light fa-folder-open',
+                    data: node,
+                },
+                {
+                    name: 'upload-file',
+                    text: 'Upload File',
+                    icon: 'fa-light fa-file-arrow-up',
+                    break: true,
+                    data: this.vm.currentFolder(),
+                },
+            ];
+        const info = {
+            name: node.type == 'file' ? 'file-info' : 'folder-info',
+            text: 'Information',
+            icon: 'fa-light fa-circle-info',
+            items: [
+                {
+                    name: 'rename',
+                    text: 'Rename',
+                    icon: 'fa-light fa-pencil',
+                    data: node,
+                },
+                {
+                    name: 'properties',
+                    text: 'Properties',
+                    icon: 'fa-light fa-memo-circle-info',
+                    break: true,
+                    data: node,
+                },
+                {
+                    name: 'lock ',
+                    text: 'Lock',
+                    icon: 'fa-light fa-lock',
+                    data: node,
+                },
+            ],
+            break: true,
+        };
+        e.items = [
+            ...open,
+            {
+                name: 'share',
+                text: 'Share',
+                icon: 'fa-light fa-share-nodes',
+                items: [
+                    {
+                        name: 'share',
+                        text: 'Share',
+                        icon: 'fa-light fa-users',
+                    },
+                    {
+                        name: 'share-with-email',
+                        text: 'Share with email',
+                        icon: 'fa-light fa-envelope',
+                    },
+                    {
+                        name: 'link',
+                        text: 'Link',
+                        icon: 'fa-light fa-link',
+                    },
+                ],
+                break: true,
+            },
+            info,
+            {
+                name: 'copy',
+                text: 'Make a copy',
+                icon: 'fa-light fa-copy',
+                data: node,
+            },
+            {
+                name: 'copy-to',
+                text: 'Copy to',
+                icon: 'fa-light fa-copy',
+                data: node,
+            },
+            {
+                name: 'move-to',
+                text: 'Move to',
+                icon: 'fa-light fa-arrow-right-arrow-left',
+                break: true,
+                data: node,
+            },
+            {
+                name: 'delete',
+                text: 'Delete',
+                color: 'danger',
+                icon: 'fa-light fa-trash',
+                data: node,
+            },
+        ];
+    }
+    handleContextMenuRootOnOpening(e) {
+        //TODO: check async translate method in acorex
+        const scope = RootConfig.config.i18n;
+        e.items = [
+            {
+                name: 'new-folder',
+                text: this.translateService.translateSync('actions.create-folder', { scope }),
+                icon: 'fa-light fa-folder-plus',
+            },
+            {
+                name: 'upload-file',
+                text: this.translateService.translateSync('actions.upload-file', { scope }),
+                icon: 'fa-light fa-file-arrow-up',
+                break: true,
+            },
+            {
+                name: 'refresh',
+                text: 'Refresh',
+                icon: 'fa-light fa-rotate-right',
+                break: true,
+            },
+            {
+                name: 'delete',
+                text: 'Delete',
+                color: 'danger',
+                icon: 'fa-light fa-trash',
+            },
+        ];
+    }
+    async handleContextMenuItemClick(e) {
+        const node = e.item.data;
+        switch (e.item.name) {
+            case 'open-folder':
+                this.handleNavigateToFolder(node.id);
+                break;
+            case 'new-folder':
+                await this.createFolder(node);
+                // Handle new folder creation
+                break;
+            case 'upload-file':
+                await this.uploadFile(node);
+                break;
+            case 'paste':
+                // Handle paste operation
+                break;
+            case 'rename':
+                this.renameNode(node);
+                break;
+            case 'delete':
+                this.deleteNode(node);
+                break;
+            case 'refresh':
+                this.vm.refresh();
+                break;
+        }
+    }
+    async createFolder(node) {
+        const folderId = node?.id ?? this.vm.currentFolder()?.id;
+        if (folderId) {
+            const result = await this.driveService.showCreateFolderDialog(this.vm.currentFolder()?.id);
+            if (result) {
+                await this.vm.refresh();
+            }
+        }
+    }
+    async deleteNode(node) {
+        if (node) {
+            await this.driveService.showDeleteNodesDialog([node.id]);
+            await this.vm.refresh();
+        }
+    }
+    async renameNode(node) {
+        if (node) {
+            const result = await this.driveService.rename(node);
+            if (result) {
+                await this.vm.refresh();
+            }
+        }
+    }
+    async uploadFile(node) {
+        const folderId = node?.id ?? this.vm.currentFolder()?.id;
+        if (folderId) {
+            // const result = await this.driveService.showCreateFolderDialog(this.vm.currentFolder()?.id);
+            // if (result) {
+            //   await this.vm.refresh();
+            // }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentExplorerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXMDocumentExplorerComponent, isStandalone: true, selector: "axm-document-explorer", viewQueries: [{ propertyName: "contextMenu", first: true, predicate: ["itemsContextMenu"], descendants: true, isSignal: true }, { propertyName: "rootContextMenu", first: true, predicate: ["rootContextMenu"], descendants: true, isSignal: true }], ngImport: i0, template: "<!-- Content -->\n<div class=\"content\">\n  <!-- Empty State -->\n  @if (vm.folders().length === 0 && vm.files().length === 0) {\n  <div class=\"ax-flex ax-flex-col ax-items-center ax-justify-center ax-py-16 ax-h-full\">\n    <ax-icon icon=\"fa-light fa-folder-open\" class=\"ax-text-6xl ax-mb-4\"></ax-icon>\n    <h3 class=\"ax-text-xl ax-font-medium ax-mb-2\">No Items Found</h3>\n    <p class=\"\">This folder is empty. Add some files or folders to get started.</p>\n  </div>\n  } @else {\n  <!-- Grid View -->\n  @if (vm.isGridView()) {\n  <!-- Folders Section -->\n  @if (vm.folders().length > 0) {\n  <div class=\"section\">\n    <h3 class=\"section-title\">Folders</h3>\n    <div class=\"items-grid\">\n      @for (folder of vm.folders(); track folder.id) {\n      <ng-container [ngTemplateOutlet]=\"gridFolderTemplate\" [ngTemplateOutletContext]=\"{ $implicit: folder }\">\n      </ng-container>\n      }\n    </div>\n  </div>\n  }\n\n  <!-- Files Section -->\n  @if (vm.files().length > 0) {\n  <div class=\"section\">\n    <h3 class=\"section-title\">Files</h3>\n    <div class=\"items-grid\">\n      @for (file of vm.files(); track file.id) {\n      <ng-container [ngTemplateOutlet]=\"gridFileTemplate\" [ngTemplateOutletContext]=\"{ $implicit: file }\">\n      </ng-container>\n      }\n    </div>\n  </div>\n  }\n  <!-- Grid View End -->\n  }\n\n  <!-- List View -->\n  @if (vm.isListView()) {\n  <div class=\"list-view\">\n    <table class=\"items-table\">\n      <thead>\n        <tr>\n          <th class=\"name-column\">Name</th>\n          <th class=\"type-column\">Type</th>\n          <th class=\"size-column\">Size</th>\n          <th class=\"date-column\">Last Modified</th>\n        </tr>\n      </thead>\n      <tbody>\n        @for (folder of vm.folders(); track folder.id) {\n        <ng-container [ngTemplateOutlet]=\"listFolderTemplate\" [ngTemplateOutletContext]=\"{ $implicit: folder }\">\n        </ng-container>\n        } @for (file of vm.files(); track file.id) {\n        <ng-container [ngTemplateOutlet]=\"listFileTemplate\" [ngTemplateOutletContext]=\"{ $implicit: file }\">\n        </ng-container>\n        }\n      </tbody>\n    </table>\n  </div>\n  } }\n</div>\n\n<!-- Grid View Templates -->\n<ng-template #gridFolderTemplate let-folder>\n  <div class=\"ax-group ax-cursor-pointer axp-explorer-item\" [axp-data]=\"folder\"\n    (dblclick)=\"handleNavigateToFolder(folder.id)\">\n    <div class=\"ax-flex ax-flex-col ax-gap-1 ax-p-4 ax-rounded-lg ax-border ax-lighter-surface\">\n      <div class=\"ax-text-yellow-400  fa-3x ax-mb-2\" style=\"--fa-animation-duration: 2s\">\n        @if (vm.isLoadingFolder(folder.id)) {\n        <ng-container [ngTemplateOutlet]=\"folderLoading\"> </ng-container>\n        } @else {\n        <ax-icon icon=\"fa-solid fa-folder-closed \"></ax-icon>\n        }\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-font-semibold ax-w-full\">\n        <span class=\"ax-text-sm ax-truncate  ax-text-start\">{{ folder.name }}</span>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-w-full ax-font-semibold ax-opacity-65\">\n        <span class=\"ax-text-xs ax-text-neutral\">15 items</span>\n        <span class=\"ax-text-xs ax-text-neutral\">{{ folder.lastModified | format : 'datetime' : { format: 'datetime' } |\n          async }}</span>\n      </div>\n    </div>\n  </div>\n</ng-template>\n\n<ng-template #gridFileTemplate let-file>\n  @let fileInfo = vm.getFileInfo(file.name);\n  <div class=\"ax-group ax-cursor-pointer axp-explorer-item\" [axp-data]=\"file\"\n    (dblclick)=\"handleNavigateToFolder(file.id)\">\n    <div class=\"ax-flex ax-flex-col ax-gap-1 ax-p-4 ax-rounded-lg ax-border ax-lighter-surface\">\n      <div class=\"ax-text-yellow-400  fa-3x ax-mb-2\" style=\"--fa-animation-duration: 2s\">\n        <i class=\"fa-fw  {{ fileInfo.icon }} fa-solid\"></i>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-font-semibold ax-w-full\">\n        <span class=\"ax-text-sm ax-truncate  ax-text-start\">{{ file.name }}</span>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-w-full ax-font-semibold ax-opacity-65\">\n        <span class=\"ax-text-xs ax-text-neutral\">{{ file.size | format : 'filesize' | async }}</span>\n        <span class=\"ax-text-xs ax-text-neutral\">{{ file.lastModified | format : 'datetime' : { format: 'datetime' } |\n          async }}</span>\n      </div>\n    </div>\n  </div>\n</ng-template>\n\n<!-- List View Templates -->\n<ng-template #listFolderTemplate let-folder>\n  <tr class=\"folder-row\" (dblclick)=\"handleNavigateToFolder(folder.id)\">\n    <td class=\"name-column axp-explorer-item\" [axp-data]=\"folder\">\n      <div class=\"item-name\">\n        @if (vm.isLoadingFolder(folder.id)) {\n        <ng-container [ngTemplateOutlet]=\"folderLoading\"> </ng-container>\n        } @else {\n        <i class=\"fas fa-folder-closed\"></i>\n        }\n        <span>{{ folder.name }}</span>\n      </div>\n    </td>\n    <td class=\"type-column axp-explorer-item\" [axp-data]=\"folder\">Folder</td>\n    <td class=\"size-column axp-explorer-item\" [axp-data]=\"folder\">{{ folder.size | format : 'filesize' | async }}</td>\n    <td class=\"date-column axp-explorer-item\" [axp-data]=\"folder\">\n      {{ folder.lastModified | format : 'datetime' : { format: 'datetime' } | async }}\n    </td>\n  </tr>\n</ng-template>\n\n<ng-template #listFileTemplate let-file>\n  <tr class=\"file-row\">\n    @let fileInfo = vm.getFileInfo(file.name);\n    <td class=\"name-column axp-explorer-item\" [axp-data]=\"file\">\n      <div class=\"item-name hover:ax-underline\">\n        <i class=\"fa-fw {{ fileInfo.icon }} fa-solid\"></i>\n        <span>{{ file.name }}</span>\n      </div>\n    </td>\n    <td class=\"type-column axp-explorer-item\" [axp-data]=\"file\">{{ fileInfo.type }}</td>\n    <td class=\"size-column axp-explorer-item\" [axp-data]=\"file\">{{ file.size | format : 'filesize' | async }}</td>\n    <td class=\"date-column axp-explorer-item\" [axp-data]=\"file\">\n      {{ file.lastModified | format : 'datetime' : { format: 'datetime' } | async }}\n    </td>\n  </tr>\n</ng-template>\n\n<ng-template #folderLoading>\n  <i class=\"fa-light fa-spinner fa-spin-pulse ax-text-2xl\"></i>\n</ng-template>\n\n<!-- Context Menu-->\n<ax-context-menu #itemsContextMenu [target]=\"'.axp-explorer-item'\" [orientation]=\"'vertical'\" [closeOn]=\"'leave'\"\n  (onItemClick)=\"handleContextMenuItemClick($event)\" (onOpening)=\"handleContextMenuOnOpening($event)\">\n</ax-context-menu>\n\n<ax-context-menu #rootContextMenu [target]=\"'axm-document-explorer'\" [orientation]=\"'vertical'\" [closeOn]=\"'leave'\"\n  (onItemClick)=\"handleContextMenuItemClick($event)\" (onOpening)=\"handleContextMenuRootOnOpening($event)\">\n</ax-context-menu>", styles: [":host{display:flex;height:100%;flex:1 1 0%;flex-direction:column;gap:1rem}:host .content{flex:1 1 0%;-webkit-user-select:none;-moz-user-select:-moz-none;user-select:none;overflow-y:auto}:host .content .loading-state{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:1rem;padding:2rem}:host .content .loading-state i{font-size:1.5rem;line-height:2rem}:host .content .section{margin-bottom:2rem}:host .content .section:last-child{margin-bottom:0}:host .content .section .section-title{margin-bottom:1rem;font-size:1.125rem;line-height:1.75rem;font-weight:500}:host .content .section .items-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(200px,1fr));gap:1rem}:host .content .list-view .items-table{width:100%;border-collapse:collapse}:host .content .list-view .items-table th{border-bottom-width:1px;padding:.75rem;text-align:start;font-weight:500;background-color:rgb(var(--ax-sys-color-surface));color:rgb(var(--ax-sys-color-on-surface));border-color:rgb(var(--ax-sys-color-border-surface))}:host .content .list-view .items-table th.name-column{width:50%}:host .content .list-view .items-table th.type-column{width:20%}:host .content .list-view .items-table th.size-column{width:15%}:host .content .list-view .items-table th.date-column{width:15%}:host .content .list-view .items-table td{border-bottom-width:1px;--tw-border-opacity: 1;border-color:rgba(var(--ax-sys-color-border-surface),var(--tw-border-opacity, 1));padding:.75rem}:host .content .list-view .items-table td.name-column .item-name{display:flex;align-items:center;gap:.5rem}:host .content .list-view .items-table td.name-column .item-name i{font-size:1.25rem;line-height:1.75rem}:host .content .list-view .items-table tr{cursor:pointer;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}:host .content .list-view .items-table tr:hover{--tw-bg-opacity: 1;background-color:rgba(var(--ax-sys-color-lighter-surface),var(--tw-bg-opacity, 1))}:host .content .list-view .items-table tr.folder-row td .item-name i{--tw-text-opacity: 1;color:rgb(234 179 8 / var(--tw-text-opacity, 1))}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: RouterModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i5$1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "ngmodule", type: AXFormatModule }, { kind: "pipe", type: i3.AXFormatPipe, name: "format" }, { kind: "ngmodule", type: AXDateTimeModule }, { kind: "ngmodule", type: AXMenuModule }, { kind: "component", type: i4.AXContextMenuComponent, selector: "ax-context-menu", inputs: ["orientation", "openOn", "closeOn", "items", "target"], outputs: ["onItemClick", "onOpening"] }, { kind: "directive", type: AXPElementDataDirective, selector: "[axp-data]", inputs: ["axp-data", "axp-data-path"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentExplorerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-document-explorer', standalone: true, imports: [
+                        CommonModule,
+                        RouterModule,
+                        AXDecoratorModule,
+                        AXLoadingModule,
+                        AXFormatModule,
+                        AXDateTimeModule,
+                        AXMenuModule,
+                        AXPElementDataDirective,
+                    ], template: "<!-- Content -->\n<div class=\"content\">\n  <!-- Empty State -->\n  @if (vm.folders().length === 0 && vm.files().length === 0) {\n  <div class=\"ax-flex ax-flex-col ax-items-center ax-justify-center ax-py-16 ax-h-full\">\n    <ax-icon icon=\"fa-light fa-folder-open\" class=\"ax-text-6xl ax-mb-4\"></ax-icon>\n    <h3 class=\"ax-text-xl ax-font-medium ax-mb-2\">No Items Found</h3>\n    <p class=\"\">This folder is empty. Add some files or folders to get started.</p>\n  </div>\n  } @else {\n  <!-- Grid View -->\n  @if (vm.isGridView()) {\n  <!-- Folders Section -->\n  @if (vm.folders().length > 0) {\n  <div class=\"section\">\n    <h3 class=\"section-title\">Folders</h3>\n    <div class=\"items-grid\">\n      @for (folder of vm.folders(); track folder.id) {\n      <ng-container [ngTemplateOutlet]=\"gridFolderTemplate\" [ngTemplateOutletContext]=\"{ $implicit: folder }\">\n      </ng-container>\n      }\n    </div>\n  </div>\n  }\n\n  <!-- Files Section -->\n  @if (vm.files().length > 0) {\n  <div class=\"section\">\n    <h3 class=\"section-title\">Files</h3>\n    <div class=\"items-grid\">\n      @for (file of vm.files(); track file.id) {\n      <ng-container [ngTemplateOutlet]=\"gridFileTemplate\" [ngTemplateOutletContext]=\"{ $implicit: file }\">\n      </ng-container>\n      }\n    </div>\n  </div>\n  }\n  <!-- Grid View End -->\n  }\n\n  <!-- List View -->\n  @if (vm.isListView()) {\n  <div class=\"list-view\">\n    <table class=\"items-table\">\n      <thead>\n        <tr>\n          <th class=\"name-column\">Name</th>\n          <th class=\"type-column\">Type</th>\n          <th class=\"size-column\">Size</th>\n          <th class=\"date-column\">Last Modified</th>\n        </tr>\n      </thead>\n      <tbody>\n        @for (folder of vm.folders(); track folder.id) {\n        <ng-container [ngTemplateOutlet]=\"listFolderTemplate\" [ngTemplateOutletContext]=\"{ $implicit: folder }\">\n        </ng-container>\n        } @for (file of vm.files(); track file.id) {\n        <ng-container [ngTemplateOutlet]=\"listFileTemplate\" [ngTemplateOutletContext]=\"{ $implicit: file }\">\n        </ng-container>\n        }\n      </tbody>\n    </table>\n  </div>\n  } }\n</div>\n\n<!-- Grid View Templates -->\n<ng-template #gridFolderTemplate let-folder>\n  <div class=\"ax-group ax-cursor-pointer axp-explorer-item\" [axp-data]=\"folder\"\n    (dblclick)=\"handleNavigateToFolder(folder.id)\">\n    <div class=\"ax-flex ax-flex-col ax-gap-1 ax-p-4 ax-rounded-lg ax-border ax-lighter-surface\">\n      <div class=\"ax-text-yellow-400  fa-3x ax-mb-2\" style=\"--fa-animation-duration: 2s\">\n        @if (vm.isLoadingFolder(folder.id)) {\n        <ng-container [ngTemplateOutlet]=\"folderLoading\"> </ng-container>\n        } @else {\n        <ax-icon icon=\"fa-solid fa-folder-closed \"></ax-icon>\n        }\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-font-semibold ax-w-full\">\n        <span class=\"ax-text-sm ax-truncate  ax-text-start\">{{ folder.name }}</span>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-w-full ax-font-semibold ax-opacity-65\">\n        <span class=\"ax-text-xs ax-text-neutral\">15 items</span>\n        <span class=\"ax-text-xs ax-text-neutral\">{{ folder.lastModified | format : 'datetime' : { format: 'datetime' } |\n          async }}</span>\n      </div>\n    </div>\n  </div>\n</ng-template>\n\n<ng-template #gridFileTemplate let-file>\n  @let fileInfo = vm.getFileInfo(file.name);\n  <div class=\"ax-group ax-cursor-pointer axp-explorer-item\" [axp-data]=\"file\"\n    (dblclick)=\"handleNavigateToFolder(file.id)\">\n    <div class=\"ax-flex ax-flex-col ax-gap-1 ax-p-4 ax-rounded-lg ax-border ax-lighter-surface\">\n      <div class=\"ax-text-yellow-400  fa-3x ax-mb-2\" style=\"--fa-animation-duration: 2s\">\n        <i class=\"fa-fw  {{ fileInfo.icon }} fa-solid\"></i>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-font-semibold ax-w-full\">\n        <span class=\"ax-text-sm ax-truncate  ax-text-start\">{{ file.name }}</span>\n      </div>\n      <div class=\"ax-flex ax-justify-between ax-w-full ax-font-semibold ax-opacity-65\">\n        <span class=\"ax-text-xs ax-text-neutral\">{{ file.size | format : 'filesize' | async }}</span>\n        <span class=\"ax-text-xs ax-text-neutral\">{{ file.lastModified | format : 'datetime' : { format: 'datetime' } |\n          async }}</span>\n      </div>\n    </div>\n  </div>\n</ng-template>\n\n<!-- List View Templates -->\n<ng-template #listFolderTemplate let-folder>\n  <tr class=\"folder-row\" (dblclick)=\"handleNavigateToFolder(folder.id)\">\n    <td class=\"name-column axp-explorer-item\" [axp-data]=\"folder\">\n      <div class=\"item-name\">\n        @if (vm.isLoadingFolder(folder.id)) {\n        <ng-container [ngTemplateOutlet]=\"folderLoading\"> </ng-container>\n        } @else {\n        <i class=\"fas fa-folder-closed\"></i>\n        }\n        <span>{{ folder.name }}</span>\n      </div>\n    </td>\n    <td class=\"type-column axp-explorer-item\" [axp-data]=\"folder\">Folder</td>\n    <td class=\"size-column axp-explorer-item\" [axp-data]=\"folder\">{{ folder.size | format : 'filesize' | async }}</td>\n    <td class=\"date-column axp-explorer-item\" [axp-data]=\"folder\">\n      {{ folder.lastModified | format : 'datetime' : { format: 'datetime' } | async }}\n    </td>\n  </tr>\n</ng-template>\n\n<ng-template #listFileTemplate let-file>\n  <tr class=\"file-row\">\n    @let fileInfo = vm.getFileInfo(file.name);\n    <td class=\"name-column axp-explorer-item\" [axp-data]=\"file\">\n      <div class=\"item-name hover:ax-underline\">\n        <i class=\"fa-fw {{ fileInfo.icon }} fa-solid\"></i>\n        <span>{{ file.name }}</span>\n      </div>\n    </td>\n    <td class=\"type-column axp-explorer-item\" [axp-data]=\"file\">{{ fileInfo.type }}</td>\n    <td class=\"size-column axp-explorer-item\" [axp-data]=\"file\">{{ file.size | format : 'filesize' | async }}</td>\n    <td class=\"date-column axp-explorer-item\" [axp-data]=\"file\">\n      {{ file.lastModified | format : 'datetime' : { format: 'datetime' } | async }}\n    </td>\n  </tr>\n</ng-template>\n\n<ng-template #folderLoading>\n  <i class=\"fa-light fa-spinner fa-spin-pulse ax-text-2xl\"></i>\n</ng-template>\n\n<!-- Context Menu-->\n<ax-context-menu #itemsContextMenu [target]=\"'.axp-explorer-item'\" [orientation]=\"'vertical'\" [closeOn]=\"'leave'\"\n  (onItemClick)=\"handleContextMenuItemClick($event)\" (onOpening)=\"handleContextMenuOnOpening($event)\">\n</ax-context-menu>\n\n<ax-context-menu #rootContextMenu [target]=\"'axm-document-explorer'\" [orientation]=\"'vertical'\" [closeOn]=\"'leave'\"\n  (onItemClick)=\"handleContextMenuItemClick($event)\" (onOpening)=\"handleContextMenuRootOnOpening($event)\">\n</ax-context-menu>", styles: [":host{display:flex;height:100%;flex:1 1 0%;flex-direction:column;gap:1rem}:host .content{flex:1 1 0%;-webkit-user-select:none;-moz-user-select:-moz-none;user-select:none;overflow-y:auto}:host .content .loading-state{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:1rem;padding:2rem}:host .content .loading-state i{font-size:1.5rem;line-height:2rem}:host .content .section{margin-bottom:2rem}:host .content .section:last-child{margin-bottom:0}:host .content .section .section-title{margin-bottom:1rem;font-size:1.125rem;line-height:1.75rem;font-weight:500}:host .content .section .items-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(200px,1fr));gap:1rem}:host .content .list-view .items-table{width:100%;border-collapse:collapse}:host .content .list-view .items-table th{border-bottom-width:1px;padding:.75rem;text-align:start;font-weight:500;background-color:rgb(var(--ax-sys-color-surface));color:rgb(var(--ax-sys-color-on-surface));border-color:rgb(var(--ax-sys-color-border-surface))}:host .content .list-view .items-table th.name-column{width:50%}:host .content .list-view .items-table th.type-column{width:20%}:host .content .list-view .items-table th.size-column{width:15%}:host .content .list-view .items-table th.date-column{width:15%}:host .content .list-view .items-table td{border-bottom-width:1px;--tw-border-opacity: 1;border-color:rgba(var(--ax-sys-color-border-surface),var(--tw-border-opacity, 1));padding:.75rem}:host .content .list-view .items-table td.name-column .item-name{display:flex;align-items:center;gap:.5rem}:host .content .list-view .items-table td.name-column .item-name i{font-size:1.25rem;line-height:1.75rem}:host .content .list-view .items-table tr{cursor:pointer;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}:host .content .list-view .items-table tr:hover{--tw-bg-opacity: 1;background-color:rgba(var(--ax-sys-color-lighter-surface),var(--tw-bg-opacity, 1))}:host .content .list-view .items-table tr.folder-row td .item-name i{--tw-text-opacity: 1;color:rgb(234 179 8 / var(--tw-text-opacity, 1))}\n"] }]
+        }] });
+
+class AXMDocumentAttachmentWidgetEditComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMDocumentAttachmentWidgetEditComponent, isStandalone: true, selector: "axm-document-attachment-widget", usesInheritance: true, ngImport: i0, template: `<axm-document-explorer></axm-document-explorer>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: AXMDocumentExplorerComponent, selector: "axm-document-explorer" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-document-attachment-widget',
+                    template: `<axm-document-explorer></axm-document-explorer>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, AXMDocumentExplorerComponent],
+                    inputs: [],
+                }]
+        }] });
+
+var documentAttachmentWidgetEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentAttachmentWidgetEditComponent: AXMDocumentAttachmentWidgetEditComponent
+});
+
+class AXMDocumentAttachmentWidgetFilterComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetFilterComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMDocumentAttachmentWidgetFilterComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetFilterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, FormsModule],
+                    inputs: [],
+                }]
+        }] });
+
+var documentAttachmentWidgetFilter_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentAttachmentWidgetFilterComponent: AXMDocumentAttachmentWidgetFilterComponent
+});
+
+class AXMDocumentAttachmentWidgetPrintComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetPrintComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMDocumentAttachmentWidgetPrintComponent, isStandalone: true, selector: "ng-component", 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: AXMDocumentAttachmentWidgetPrintComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: [],
+                }]
+        }] });
+
+var documentAttachmentWidgetPrint_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentAttachmentWidgetPrintComponent: AXMDocumentAttachmentWidgetPrintComponent
+});
+
+class AXMDocumentAttachmentWidgetViewComponent extends AXPWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMDocumentAttachmentWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXMDocumentAttachmentWidgetViewComponent, isStandalone: true, selector: "axp-document-attachment-widget", 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: AXMDocumentAttachmentWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-document-attachment-widget',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    inputs: [],
+                }]
+        }] });
+
+var documentAttachmentWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMDocumentAttachmentWidgetViewComponent: AXMDocumentAttachmentWidgetViewComponent
+});
+
+const AXMDocumentAttachmentWidget = {
+    name: 'document-attachment-editor',
+    title: 'DocumentAttachment',
+    icon: 'fa-solid fa-gallery',
+    description: 'My custom widget',
+    group: AXP_WIDGETS_EDITOR_GROUP,
+    type: 'editor',
+    defaultFilterWidgetName: 'string-filter',
+    properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetView_component; }).then((c) => c.AXMDocumentAttachmentWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetEdit_component; }).then((c) => c.AXMDocumentAttachmentWidgetEditComponent),
+        },
+        filter: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetFilter_component; }).then((c) => c.AXMDocumentAttachmentWidgetFilterComponent),
+        },
+        column: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetColumn_component; }).then((c) => c.AXMDocumentAttachmentWidgetColumnComponent),
+        },
+        print: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetPrint_component; }).then((c) => c.AXMDocumentAttachmentWidgetPrintComponent),
+        },
+        designer: {
+            component: () => Promise.resolve().then(function () { return documentAttachmentWidgetEdit_component; }).then((c) => c.AXMDocumentAttachmentWidgetEditComponent),
+        },
+    },
+};
+
+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-Sz198sA6.mjs').then((c) => c.AXMDocumentDriveComponent),
+                },
+                {
+                    path: ':id',
+                    loadComponent: () => import('./acorex-modules-document-management-drive.component-Sz198sA6.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, AXMDocumentAttachmentWidget],
+            }),
+            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, AXMDocumentAttachmentWidget],
+                        }),
+                        AXMFileTypeModule,
+                    ],
+                    exports: [],
+                    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,
+                        },
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMDocumentManagerService as A, AXMFolderServiceImpl as B, AXMEntityProvider as C, AXMMenuProvider as D, AXMSearchCommandProvider as E, AXMSettingProvider as F, RootConfig as R, AXPDocumentExplorerViewModel as a, AXMDocumentExplorerComponent as b, AXMDriveScope as c, AXMDocumentManagementModule as d, documentFactory as e, AXMDocumentManagementDocumentEntityModule as f, AXMDocumentService as g, AXMDocumentServiceImpl as h, documentTypeFactory as i, AXMDocumentManagementDocumentTypeEntityModule as j, AXMDocumentManagementDocumentTypeEntityService as k, AXMDocumentManagementDocumentTypeEntityServiceImpl as l, documentTypeMetaDefinitionfactory as m, AXMDocumentManagementDocumentTypeMetaDefinitionEntityModule as n, AXMDocumentManagementDocumentTypeMetaDefinitionEntityService as o, AXMDocumentManagementDocumentTypeMetaDefinitionEntityServiceImpl as p, documentTypeMetaValueFactory as q, AXMDocumentManagementDocumentTypeMetaValueEntityModule as r, AXMDocumentManagementDocumentTypeMetaValueEntityService as s, AXMDocumentManagementDocumentTypeMetaValueEntityServiceImpl as t, documentTypeStatusDefinitionFactory as u, AXMDocumentManagementDocumentTypeStatusDefinitionEntityModule as v, AXMDocumentManagementDocumentTypeStatusDefinitionEntityService as w, AXMDocumentManagementDocumentTypeStatusDefinitionEntityServiceImpl as x, folderFactory as y, AXMFolderService as z };
+//# sourceMappingURL=acorex-modules-document-management-acorex-modules-document-management-C9ZCejjs.mjs.map