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 { AXMEntityCrudServiceImpl, AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
import * as i0 from '@angular/core';
import { Injectable, 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',
        },
        manualAssetCategory: {
            name: 'ManualAssetCategory',
            source: `${config.module}.ManualAssetCategory`,
            title: '@asset-management:asset-categories.entities.asset-category.title',
            titlePlural: '@asset-management:asset-categories.entities.asset-category.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 ----   Service   ----
class AXMAssetManagementAssetEntityService extends AXMEntityCrudServiceImpl {
}
class AXMAssetManagementAssetEntityServiceImpl extends AXMAssetManagementAssetEntityService {
    constructor() {
        super(`${RootConfig.module.name}.${RootConfig.entities.asset.name}`);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityServiceImpl }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityServiceImpl, decorators: [{
            type: Injectable
        }], ctorParameters: () => [] });

//#region ----   Imports   ----
//#endregion
//#region ----   Module   ----
class AXMAssetManagementAssetEntityModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityModule, providers: [
            {
                provide: AXMAssetManagementAssetEntityService,
                useClass: AXMAssetManagementAssetEntityServiceImpl,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementAssetEntityModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: AXMAssetManagementAssetEntityService,
                            useClass: AXMAssetManagementAssetEntityServiceImpl,
                        },
                    ],
                }]
        }] });

//#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.19", ngImport: i0, type: AXMAssetManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementModule, imports: [AXMAssetManagementAssetEntityModule] }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", 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)),
        ], imports: [AXMAssetManagementAssetEntityModule] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMAssetManagementModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [AXMAssetManagementAssetEntityModule],
                    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-D_w4zjNb.mjs')).factory(this.injector);
                // case RootConfig.entities.inspection.name:
                //   return (await import('./entities/inspection/inspection.entity')).factory(this.injector);
                case RootConfig.entities.manualAssetCategory.name:
                    return (await import('./acorex-modules-asset-management-manual-asset-category.entity-DyIV_vbE.mjs')).factory(this.injector);
                // case RootConfig.entities.assetStatus.name:
                //     return (await import('./entities/asset-status/asset-status.entity')).factory(this.injector);
            }
        }
        return null;
    }
    async list() {
        const m = RootConfig.module.name;
        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
    }
}
//#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',
    // 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',
        },
        // 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,
                        // children: [
                        //   {
                        //     name: `${AXMAssetManagementMenuKeys.Assets}:assets`,
                        //     text: RootConfig.entities.asset.titlePlural,
                        //     icon: RootConfig.entities.asset.icon,
                        //     path: this.entityService.createPath(module.name, RootConfig.entities.asset.name),
                        //     priority: 1,
                        //   },
                        // ],
                    },
                    // {
                    //   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()
            .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
