@acorex/modules 21.0.0-next.10 → 21.0.0-next.11

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

@@ -1,2 +1,621 @@
-export { j as AXMAssetManagementAssetEntityService, k as AXMAssetManagementAssetEntityServiceImpl, m as AXMAssetManagementAssetStatusProvider, d as AXMAssetManagementEntityProvider, e as AXMAssetManagementMenuKeys, f as AXMAssetManagementMenuProvider, c as AXMAssetManagementModule, g as AXMAssetManagementPermissionDefinitionProvider, h as AXMAssetManagementPermissionKeys, i as AXMAssetManagementSearchCommandProvider, l as AXMAssetStatus, R as RootConfig } from './acorex-modules-asset-management-acorex-modules-asset-management-CZchW21Z.mjs';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXP_STATUS_PROVIDERS, AXPSearchCommandProvider, AXPStatusProvider } from '@acorex/platform/common';
+import { AXP_MODULE_MANIFEST_PROVIDER, provideLazyProvider, AXP_FEATURE_DEFINITION_PROVIDER } from '@acorex/platform/core';
+import { AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
+import * as i0 from '@angular/core';
+import { NgModule, inject, Injector } from '@angular/core';
+
+//#region ----   Root Configuration   ----
+const config = {
+    i18n: 'asset-management',
+    module: 'AssetManagement',
+    route: 'asset-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: config.route,
+        name: config.module,
+        title: '@asset-management:module.title',
+        icon: 'fa-light fa-box',
+    },
+    entities: {
+        asset: {
+            name: 'Asset',
+            source: `${config.module}.Asset`,
+            title: '@asset-management:assets.entities.asset.title',
+            titlePlural: '@asset-management:assets.entities.asset.plural',
+            icon: 'fa-light fa-boxes-stacked',
+        },
+        maintenance: {
+            name: 'Maintenance',
+            source: `${config.module}.Maintenance`,
+            title: '@asset-management:maintenances.entities.maintenance.title',
+            titlePlural: '@asset-management:maintenances.entities.maintenance.plural',
+            icon: 'fa-light fa-clipboard-list',
+        },
+        maintenanceType: {
+            name: 'MaintenanceType',
+            source: `${config.module}.MaintenanceType`,
+            title: '@asset-management:maintenance-types.entities.maintenance-type.title',
+            titlePlural: '@asset-management:maintenance-types.entities.maintenance-type.plural',
+            icon: 'fa-light fa-tags',
+        },
+        inspection: {
+            name: 'Inspection',
+            source: `${config.module}.Inspection`,
+            title: '@asset-management:inspections.entities.inspection.title',
+            titlePlural: '@asset-management:inspections.entities.inspection.plural',
+            icon: 'fa-light fa-clipboard-check',
+        },
+        // assetStatus: {
+        //     name: 'AssetStatus',
+        //     source: `${config.module}.AssetStatus`,
+        //     title: '@asset-management:asset-statuses.entities.asset-status.title',
+        //     titlePlural: '@asset-management:asset-statuses.entities.asset-status.plural',
+        //     icon: 'fa-light fa-signal',
+        // },
+    },
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Asset Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const AssetManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: false,
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMAssetManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AXMAssetManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: AXMAssetManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AXMAssetManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: AssetManagementManifest,
+                multi: true,
+            },
+            // Feature Definition Provider (lazy-loaded)
+            provideLazyProvider(AXP_FEATURE_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return featureDefinition_provider; }).then((m) => m.AXMAssetManagementFeatureDefinitionProvider)),
+            // Permission Definition Provider (lazy-loaded)
+            provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMAssetManagementPermissionDefinitionProvider)),
+            // Menu Provider (lazy-loaded)
+            provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMAssetManagementMenuProvider)),
+            // Entity Provider (lazy-loaded)
+            provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMAssetManagementEntityProvider)),
+            // Search Provider (lazy-loaded)
+            provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return search_provider; }).then((m) => m.AXMAssetManagementSearchCommandProvider)),
+            // Status Providers
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return assetStatus_provider; }).then((m) => m.AXMAssetManagementAssetStatusProvider)),
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AXMAssetManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: AssetManagementManifest,
+                            multi: true,
+                        },
+                        // Feature Definition Provider (lazy-loaded)
+                        provideLazyProvider(AXP_FEATURE_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return featureDefinition_provider; }).then((m) => m.AXMAssetManagementFeatureDefinitionProvider)),
+                        // Permission Definition Provider (lazy-loaded)
+                        provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMAssetManagementPermissionDefinitionProvider)),
+                        // Menu Provider (lazy-loaded)
+                        provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMAssetManagementMenuProvider)),
+                        // Entity Provider (lazy-loaded)
+                        provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMAssetManagementEntityProvider)),
+                        // Search Provider (lazy-loaded)
+                        provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return search_provider; }).then((m) => m.AXMAssetManagementSearchCommandProvider)),
+                        // Status Providers
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return assetStatus_provider; }).then((m) => m.AXMAssetManagementAssetStatusProvider)),
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Provider   ----
+class AXMAssetManagementEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    async get(moduleName, entityName) {
+        if (moduleName === RootConfig.module.name) {
+            switch (entityName) {
+                case RootConfig.entities.asset.name:
+                    return (await import('./acorex-modules-asset-management-asset.entity-C57iN3Bo.mjs')).factory(this.injector);
+                case RootConfig.entities.maintenance.name:
+                    return (await import('./acorex-modules-asset-management-maintenance.entity-Cxzcn0Ae.mjs')).factory(this.injector);
+                case RootConfig.entities.maintenanceType.name:
+                    return (await import('./acorex-modules-asset-management-maintenance-type.entity-T3iF8l5n.mjs')).factory(this.injector);
+                case RootConfig.entities.inspection.name:
+                    return (await import('./acorex-modules-asset-management-inspection.entity-CpDuN-qj.mjs')).factory(this.injector);
+                // case RootConfig.entities.assetStatus.name:
+                //     return (await import('./entities/asset-status/asset-status.entity')).factory(this.injector);
+            }
+        }
+        return null;
+    }
+}
+//#endregion
+
+var entity_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementEntityProvider: AXMAssetManagementEntityProvider
+});
+
+const AXMAssetManagementFeatureKeys = {
+    AssetManagement: 'AssetManagement:Feature:Management',
+    AdvancedMaintenance: 'AssetManagement:Feature:Advanced.Maintenance',
+    MaintenanceScheduling: 'AssetManagement:Feature:Maintenance.Scheduling',
+    InspectionWorkflow: 'AssetManagement:Feature:Inspection.Workflow',
+};
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Feature Definition Provider   ----
+/**
+ * Asset Management Feature Definition Provider.
+ * Provides feature definitions for the Asset Management module.
+ */
+class AXMAssetManagementFeatureDefinitionProvider {
+    async provide(context) {
+        // Asset Management feature
+        context.addFeature(AXMAssetManagementFeatureKeys.AssetManagement, {
+            title: '@asset-management:features.asset-management.title',
+            description: '@asset-management:features.asset-management.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        // Advanced Maintenance feature
+        context.addFeature(AXMAssetManagementFeatureKeys.AdvancedMaintenance, {
+            title: '@asset-management:features.advanced-maintenance.title',
+            description: '@asset-management:features.advanced-maintenance.description',
+            defaultValue: false,
+            type: 'boolean',
+        });
+        // Maintenance Scheduling feature
+        context.addFeature(AXMAssetManagementFeatureKeys.MaintenanceScheduling, {
+            title: '@asset-management:features.maintenance-scheduling.title',
+            description: '@asset-management:features.maintenance-scheduling.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        // Inspection Workflow feature
+        context.addFeature(AXMAssetManagementFeatureKeys.InspectionWorkflow, {
+            title: '@asset-management:features.inspection-workflow.title',
+            description: '@asset-management:features.inspection-workflow.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+    }
+}
+//#endregion
+
+var featureDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementFeatureDefinitionProvider: AXMAssetManagementFeatureDefinitionProvider
+});
+
+const AXMAssetManagementMenuKeys = {
+    Root: 'AssetManagement:Menu',
+    Assets: 'AssetManagement:Menu:Assets',
+    Maintenances: 'AssetManagement:Menu:Maintenances',
+    MaintenanceTypes: 'AssetManagement:Menu:MaintenanceTypes',
+    Inspections: 'AssetManagement:Menu:Inspections',
+};
+
+const AXMAssetManagementPermissionKeys = {
+    AssetManagement: {
+        Management: 'AssetManagement:Permission:AssetManagement.Management',
+        Asset: {
+            Management: 'AssetManagement:Permission:Asset.Management',
+            View: 'AssetManagement:Permission:Asset.View',
+            Create: 'AssetManagement:Permission:Asset.Create',
+            Update: 'AssetManagement:Permission:Asset.Update',
+            Delete: 'AssetManagement:Permission:Asset.Delete',
+        },
+        MaintenanceType: {
+            Management: 'AssetManagement:Permission:MaintenanceType.Management',
+            View: 'AssetManagement:Permission:MaintenanceType.View',
+            Create: 'AssetManagement:Permission:MaintenanceType.Create',
+            Update: 'AssetManagement:Permission:MaintenanceType.Update',
+            Delete: 'AssetManagement:Permission:MaintenanceType.Delete',
+        },
+        Maintenance: {
+            Management: 'AssetManagement:Permission:Maintenance.Management',
+            View: 'AssetManagement:Permission:Maintenance.View',
+            Create: 'AssetManagement:Permission:Maintenance.Create',
+            Update: 'AssetManagement:Permission:Maintenance.Update',
+            Delete: 'AssetManagement:Permission:Maintenance.Delete',
+        },
+        Inspection: {
+            Management: 'AssetManagement:Permission:Inspection.Management',
+            View: 'AssetManagement:Permission:Inspection.View',
+            Create: 'AssetManagement:Permission:Inspection.Create',
+            Update: 'AssetManagement:Permission:Inspection.Update',
+            Delete: 'AssetManagement:Permission:Inspection.Delete',
+        },
+    },
+};
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Menu Provider   ----
+/**
+ * Asset Management Menu Provider.
+ * Provides menu items for the Asset Management module with permission and feature checks.
+ */
+class AXMAssetManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const keys = AXMAssetManagementPermissionKeys.AssetManagement;
+        context.addItems([
+            {
+                name: AXMAssetManagementMenuKeys.Root,
+                priority: 9050,
+                text: module.title,
+                icon: module.icon,
+                policy: {
+                    features: [module.name],
+                },
+                children: [
+                    {
+                        name: AXMAssetManagementMenuKeys.Assets,
+                        text: RootConfig.entities.asset.titlePlural,
+                        icon: RootConfig.entities.asset.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.asset.name),
+                        priority: 1,
+                        policy: {
+                            permissions: [keys.Asset.View],
+                        },
+                    },
+                    {
+                        name: AXMAssetManagementMenuKeys.Maintenances,
+                        text: RootConfig.entities.maintenance.titlePlural,
+                        icon: RootConfig.entities.maintenance.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.maintenance.name),
+                        priority: 2,
+                        policy: {
+                            permissions: [keys.Maintenance.View],
+                        },
+                    },
+                    {
+                        name: AXMAssetManagementMenuKeys.MaintenanceTypes,
+                        text: RootConfig.entities.maintenanceType.titlePlural,
+                        icon: RootConfig.entities.maintenanceType.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.maintenanceType.name),
+                        priority: 3,
+                        policy: {
+                            permissions: [keys.MaintenanceType.View],
+                        },
+                    },
+                    {
+                        name: AXMAssetManagementMenuKeys.Inspections,
+                        text: RootConfig.entities.inspection.titlePlural,
+                        icon: RootConfig.entities.inspection.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.inspection.name),
+                        priority: 4,
+                        policy: {
+                            permissions: [keys.Inspection.View],
+                        },
+                    },
+                ],
+            },
+        ]);
+    }
+}
+//#endregion
+
+var menu_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementMenuProvider: AXMAssetManagementMenuProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Permission Definition Provider   ----
+/**
+ * Asset Management Permission Definition Provider.
+ * Provides permission definitions for the Asset Management module.
+ */
+class AXMAssetManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXMAssetManagementPermissionKeys.AssetManagement;
+        // I18n path constants for cleaner code
+        const MODULE_PERMISSIONS = '@asset-management:module.permissions';
+        const ASSETS_PERMISSIONS = '@asset-management:assets.permissions';
+        const MAINTENANCE_TYPES_PERMISSIONS = '@asset-management:maintenance-types.permissions';
+        const MAINTENANCES_PERMISSIONS = '@asset-management:maintenances.permissions';
+        const INSPECTIONS_PERMISSIONS = '@asset-management:inspections.permissions';
+        context
+            .addGroup(keys.Management, `${MODULE_PERMISSIONS}.title`, `${MODULE_PERMISSIONS}.description`)
+            .addPermission(keys.Asset.Management, `${ASSETS_PERMISSIONS}.manage.title`, `${ASSETS_PERMISSIONS}.manage.description`)
+            .addChild(keys.Asset.View, `${ASSETS_PERMISSIONS}.view.title`, `${ASSETS_PERMISSIONS}.view.description`)
+            .addChild(keys.Asset.Create, `${ASSETS_PERMISSIONS}.create.title`, `${ASSETS_PERMISSIONS}.create.description`)
+            .addChild(keys.Asset.Update, `${ASSETS_PERMISSIONS}.edit.title`, `${ASSETS_PERMISSIONS}.edit.description`)
+            .addChild(keys.Asset.Delete, `${ASSETS_PERMISSIONS}.delete.title`, `${ASSETS_PERMISSIONS}.delete.description`)
+            .endPermission()
+            .addPermission(keys.MaintenanceType.Management, `${MAINTENANCE_TYPES_PERMISSIONS}.manage.title`, `${MAINTENANCE_TYPES_PERMISSIONS}.manage.description`)
+            .addChild(keys.MaintenanceType.View, `${MAINTENANCE_TYPES_PERMISSIONS}.view.title`, `${MAINTENANCE_TYPES_PERMISSIONS}.view.description`)
+            .addChild(keys.MaintenanceType.Create, `${MAINTENANCE_TYPES_PERMISSIONS}.create.title`, `${MAINTENANCE_TYPES_PERMISSIONS}.create.description`)
+            .addChild(keys.MaintenanceType.Update, `${MAINTENANCE_TYPES_PERMISSIONS}.edit.title`, `${MAINTENANCE_TYPES_PERMISSIONS}.edit.description`)
+            .addChild(keys.MaintenanceType.Delete, `${MAINTENANCE_TYPES_PERMISSIONS}.delete.title`, `${MAINTENANCE_TYPES_PERMISSIONS}.delete.description`)
+            .endPermission()
+            .addPermission(keys.Maintenance.Management, `${MAINTENANCES_PERMISSIONS}.manage.title`, `${MAINTENANCES_PERMISSIONS}.manage.description`)
+            .addChild(keys.Maintenance.View, `${MAINTENANCES_PERMISSIONS}.view.title`, `${MAINTENANCES_PERMISSIONS}.view.description`)
+            .addChild(keys.Maintenance.Create, `${MAINTENANCES_PERMISSIONS}.create.title`, `${MAINTENANCES_PERMISSIONS}.create.description`)
+            .addChild(keys.Maintenance.Update, `${MAINTENANCES_PERMISSIONS}.edit.title`, `${MAINTENANCES_PERMISSIONS}.edit.description`)
+            .addChild(keys.Maintenance.Delete, `${MAINTENANCES_PERMISSIONS}.delete.title`, `${MAINTENANCES_PERMISSIONS}.delete.description`)
+            .endPermission()
+            .addPermission(keys.Inspection.Management, `${INSPECTIONS_PERMISSIONS}.manage.title`, `${INSPECTIONS_PERMISSIONS}.manage.description`)
+            .addChild(keys.Inspection.View, `${INSPECTIONS_PERMISSIONS}.view.title`, `${INSPECTIONS_PERMISSIONS}.view.description`)
+            .addChild(keys.Inspection.Create, `${INSPECTIONS_PERMISSIONS}.create.title`, `${INSPECTIONS_PERMISSIONS}.create.description`)
+            .addChild(keys.Inspection.Update, `${INSPECTIONS_PERMISSIONS}.edit.title`, `${INSPECTIONS_PERMISSIONS}.edit.description`)
+            .addChild(keys.Inspection.Delete, `${INSPECTIONS_PERMISSIONS}.delete.title`, `${INSPECTIONS_PERMISSIONS}.delete.description`)
+            .endPermission()
+            .endGroup();
+    }
+}
+//#endregion
+
+var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementPermissionDefinitionProvider: AXMAssetManagementPermissionDefinitionProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Search Provider   ----
+class AXMAssetManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                group: 'entity',
+                title: '@asset-management:assets.search.create-asset.title',
+                icon: RootConfig.entities.asset.icon,
+                description: '@asset-management:assets.search.create-asset.description',
+                command: {
+                    name: 'create-entity',
+                    options: {
+                        entity: `${RootConfig.module.name}.${RootConfig.entities.asset.name}`,
+                    },
+                },
+            },
+            // {
+            //     group: 'entity',
+            //     title: '@asset-management:asset-statuses.search.create-asset-status.title',
+            //     icon: RootConfig.entities.assetStatus.icon,
+            //     description: '@asset-management:asset-statuses.search.create-asset-status.description',
+            //     command: {
+            //         name: 'create-entity',
+            //         options: {
+            //             entity: `${RootConfig.module.name}.${RootConfig.entities.assetStatus.name}`,
+            //         },
+            //     },
+            // },
+        ];
+    }
+}
+//#endregion
+
+var search_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementSearchCommandProvider: AXMAssetManagementSearchCommandProvider
+});
+
+// import { AXPStatusProvider, AXPStatusTransition } from '@acorex/platform/core';
+var AXMAssetStatus;
+(function (AXMAssetStatus) {
+    AXMAssetStatus["Available"] = "available";
+    AXMAssetStatus["Inactive"] = "inactive";
+    AXMAssetStatus["Suspended"] = "suspended";
+    AXMAssetStatus["Transferring"] = "transferring";
+    AXMAssetStatus["UnderRepair"] = "under-repair";
+    AXMAssetStatus["OutOfOrder"] = "out-of-order";
+    AXMAssetStatus["Retired"] = "retired";
+    AXMAssetStatus["Archived"] = "archived";
+})(AXMAssetStatus || (AXMAssetStatus = {}));
+class AXMAssetManagementAssetStatusProvider extends AXPStatusProvider {
+    constructor() {
+        super(...arguments);
+        this.key = 'asset-management.status.asset';
+        this.statuses = [
+            {
+                name: AXMAssetStatus.Available,
+                title: '@asset-management:assets.states.available',
+                icon: 'fa-light fa-circle-check',
+                color: 'success',
+                order: 1,
+                isInitial: true,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Inactive,
+                title: '@asset-management:assets.states.inactive',
+                icon: 'fa-light fa-circle',
+                color: 'secondary',
+                order: 2,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Suspended,
+                title: '@asset-management:assets.states.suspended',
+                icon: 'fa-light fa-circle-pause',
+                color: 'warning',
+                order: 3,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Transferring,
+                title: '@asset-management:assets.states.transferring',
+                icon: 'fa-light fa-truck',
+                color: 'info',
+                order: 4,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.UnderRepair,
+                title: '@asset-management:assets.states.under-repair',
+                icon: 'fa-light fa-screwdriver-wrench',
+                color: 'warning',
+                order: 5,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.OutOfOrder,
+                title: '@asset-management:assets.states.out-of-order',
+                icon: 'fa-light fa-triangle-exclamation',
+                color: 'danger',
+                order: 6,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Retired,
+                title: '@asset-management:assets.states.retired',
+                icon: 'fa-light fa-ban',
+                color: 'neutral',
+                order: 7,
+                isInitial: false,
+                isFinal: true,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Archived,
+                title: '@asset-management:assets.states.archived',
+                icon: 'fa-light fa-box-archive',
+                color: 'neutral',
+                order: 8,
+                isInitial: false,
+                isFinal: true,
+                generateView: true,
+            },
+        ];
+        this.transitions = [
+            // ---- Availability flow
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Transferring,
+                title: '@asset-management:assets.transitions.start-transfer',
+                // color: 'info' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Transferring,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.transfer-complete',
+                // color: 'success' as AXStyleColorType,
+            },
+            // ---- Repair flow
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.UnderRepair,
+                title: '@asset-management:assets.transitions.send-to-repair',
+                // color: 'warning' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.UnderRepair,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.repair-complete',
+                // color: 'success' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.OutOfOrder,
+                title: '@asset-management:assets.transitions.mark-out-of-order',
+                // color: 'danger' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.OutOfOrder,
+                to: AXMAssetStatus.UnderRepair,
+                title: '@asset-management:assets.transitions.send-to-repair',
+                // color: 'warning' as AXStyleColorType,
+            },
+            // ---- Enable / disable
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Inactive,
+                title: '@general:statuses.transitions.deactivate',
+                // color: 'secondary' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Inactive,
+                to: AXMAssetStatus.Available,
+                title: '@general:statuses.transitions.activate',
+                // color: 'success' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Suspended,
+                title: '@general:statuses.transitions.suspend',
+                // color: 'warning' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Suspended,
+                to: AXMAssetStatus.Available,
+                title: '@general:statuses.transitions.activate',
+                // color: 'success' as AXStyleColorType,
+            },
+            // ---- End of lifecycle
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Retired,
+                title: '@asset-management:assets.transitions.retire',
+                // color: 'neutral' as AXStyleColorType,
+            },
+            {
+                from: AXMAssetStatus.Retired,
+                to: AXMAssetStatus.Archived,
+                title: '@general:statuses.transitions.archive',
+                // color: 'neutral' as AXStyleColorType,
+            },
+        ];
+        this.defaultStatus = AXMAssetStatus.Available;
+    }
+}
+
+var assetStatus_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementAssetStatusProvider: AXMAssetManagementAssetStatusProvider,
+    get AXMAssetStatus () { return AXMAssetStatus; }
+});
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMAssetManagementAssetStatusProvider, AXMAssetManagementEntityProvider, AXMAssetManagementFeatureDefinitionProvider, AXMAssetManagementFeatureKeys, AXMAssetManagementMenuKeys, AXMAssetManagementMenuProvider, AXMAssetManagementModule, AXMAssetManagementPermissionDefinitionProvider, AXMAssetManagementPermissionKeys, AXMAssetManagementSearchCommandProvider, AXMAssetStatus, RootConfig };
 //# sourceMappingURL=acorex-modules-asset-management.mjs.map