@acorex-platform/module-asset-management-client 0.0.20

package/fesm2022/acorex-platform-module-asset-management-client.mjs

@@ -0,0 +1,2472 @@
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXP_STATUS_PROVIDERS, AXPSearchCommandProvider, createEntityCommandOptions } from '@acorex-platform/framework-client/common';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, provideLazyProvider, AXP_FEATURE_DEFINITION_PROVIDER, AXPDataGenerator } from '@acorex-platform/framework-client/core';
+import { AXP_PAGE_COMPONENT_PROVIDER, AXPStandardSectionItemsBuilderComponent } from '@acorex-platform/framework-client/layout/components';
+import { AXPMiddlewareAbortError, AXP_ENTITY_STORAGE_MIDDLEWARE, AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { provideCommand, provideCommandSetups, AXPCommandService } from '@acorex-platform/framework-client/runtime';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, inject, input, output, viewChild, signal, computed, effect, ChangeDetectionStrategy, Component, untracked } from '@angular/core';
+import * as contracts from '@acorex-platform/module-asset-management-client/contracts';
+import { ASSET_CATALOG_SCOPE_BOOKING, RootConfig, AXMAssetManagementCommandKeys, AXMAssetManagementFeatureKeys, AXPAssetsMaintenancePermissionKeys, AXMAssetManagementMenuKeys, AXM_ASSET_STATUS_DEFINITION_KEY, AXMAssetStatus, ASSET_TYPE_COMPONENTS_PAGE_COMPONENT_KEY, AXMAssetLifecycleStatus } from '@acorex-platform/module-asset-management-client/contracts';
+export * from '@acorex-platform/module-asset-management-client/contracts';
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPStatusProvider, AXPWidgetsCatalog } from '@acorex-platform/framework-shared/core';
+import { merge, get, isEqual, cloneDeep, isString, defaultTo } from 'lodash';
+import * as i1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i4 from '@acorex/core/translation';
+import { AXTranslationService, resolveMultiLanguageString, AXTranslationModule } from '@acorex/core/translation';
+import { AXPLayoutBuilderService } from '@acorex-platform/framework-client/layout/builder';
+import * as i3 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { AXPPageLayoutBaseComponent, AXPPageLayoutBase } from '@acorex-platform/framework-client/layout/views';
+
+function _mergeNamespaces(n, m) {
+    m.forEach(function (e) {
+        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+            if (k !== 'default' && !(k in n)) {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    });
+    return Object.freeze(n);
+}
+
+//#endregion
+//#region ---- Constants ----
+const QUESTIONNAIRE = 'AssessmentManagement.Questionnaire';
+const QUESTION_BANK_ITEM = 'AssessmentManagement.QuestionBankItem';
+const WORKFLOW_DEFINITION = 'WorkflowManagement.WorkflowDefinition';
+const ASSET_CATALOG_TARGETS = [QUESTIONNAIRE, QUESTION_BANK_ITEM, WORKFLOW_DEFINITION];
+//#endregion
+//#region ---- Provider ----
+class AXMAssetManagementCatalogScopeDefinitionProvider {
+    async items() {
+        return [
+            {
+                name: ASSET_CATALOG_SCOPE_BOOKING,
+                title: '@asset-management:catalog-scopes.booking.title',
+                description: '@asset-management:catalog-scopes.booking.description',
+                targets: [...ASSET_CATALOG_TARGETS],
+                icon: 'fa-light fa-calendar-check',
+                cssClass: 'primary-surface',
+                order: 25,
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementCatalogScopeDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementCatalogScopeDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#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,
+    type: 'domain',
+    domain: 'asset-maintenance',
+    required: false,
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Asset System Type Has Child Middleware   ----
+/**
+ * Enriches AssetSystemType query results with `hasChild` for hierarchical tree views.
+ * Uses `childrenCount` from the storage query pipeline when available.
+ */
+const assetSystemTypeHasChildMiddleware = {
+    target: {
+        ops: ['query', 'queryAll'],
+        entity: `${RootConfig.module.name}.${RootConfig.entities.assetSystemType.name}`,
+        order: 10,
+    },
+    execute: async (ctx, next) => {
+        await next();
+        if (!ctx.result?.items?.length) {
+            return;
+        }
+        ctx.result = {
+            ...ctx.result,
+            items: ctx.result.items.map((item) => ({
+                ...item,
+                hasChild: (item.childrenCount ?? 0) > 0,
+            })),
+        };
+    },
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Persist validation   ----
+function hasPartyId(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function assertRentalPartyForDirection(data) {
+    if (data.rentalDirection === 'rentTo' && !hasPartyId(data.rentedToId)) {
+        throw new Error('@asset-management:assetRentalHistories.entities.assetRentalHistory.validations.rented-to-required');
+    }
+    if (data.rentalDirection === 'rentFrom' && !hasPartyId(data.rentedFromId)) {
+        throw new Error('@asset-management:assetRentalHistories.entities.assetRentalHistory.validations.rented-from-required');
+    }
+    if (!hasPartyId(data.rentedToId) && !hasPartyId(data.rentedFromId)) {
+        throw new Error('@asset-management:assetRentalHistories.entities.assetRentalHistory.validations.rental-party-required');
+    }
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Asset Rental History Party Middleware   ----
+/**
+ * Ensures the supplier party matching rentalDirection is set, and clears the opposite party.
+ */
+const assetRentalHistoryPartyMiddleware = {
+    target: {
+        ops: ['create', 'update'],
+        entity: `${RootConfig.module.name}.${RootConfig.entities.assetRentalHistory.name}`,
+        order: 8,
+    },
+    execute: async (ctx, next) => {
+        if (!ctx.data || typeof ctx.data !== 'object') {
+            await next();
+            return;
+        }
+        const incoming = ctx.data;
+        let previous = (ctx.previous ?? {});
+        if (ctx.op === 'update' && ctx.id != null && !ctx.previous) {
+            previous = (await ctx.backend.getOne(ctx.entityName, ctx.id).catch(() => ({})));
+        }
+        const merged = {
+            ...previous,
+            ...incoming,
+        };
+        if (merged.rentalDirection === 'rentTo') {
+            incoming.rentedFromId = null;
+            incoming.rentedFrom = undefined;
+            merged.rentedFromId = null;
+            merged.rentedFrom = undefined;
+        }
+        else if (merged.rentalDirection === 'rentFrom') {
+            incoming.rentedToId = null;
+            incoming.rentedTo = undefined;
+            merged.rentedToId = null;
+            merged.rentedTo = undefined;
+        }
+        try {
+            assertRentalPartyForDirection(merged);
+        }
+        catch (error) {
+            throw new AXPMiddlewareAbortError(error instanceof Error ? error.message : String(error), {
+                code: 'RENTAL_PARTY_REQUIRED',
+                status: 400,
+            });
+        }
+        await next();
+    },
+};
+//#endregion
+
+//#region ----   Middleware Exports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMAssetManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: AssetManagementManifest,
+                multi: true,
+            },
+            {
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMAssetManagementCatalogScopeDefinitionProvider,
+                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)
+            // Search Provider (lazy-loaded)
+            provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMAssetManagementSearchCommandProvider)),
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => Promise.resolve().then(function () { return index; }).then((m) => m.AXMAssetTypeComponentsPageComponentProvider)),
+            provideCommand('AssetType:Components:Save', () => Promise.resolve().then(function () { return saveAssetTypeComponents_command; }).then((m) => m.AXMSaveAssetTypeComponentsCommand)),
+            provideCommand(AXMAssetManagementCommandKeys.AssetRentalHistory.RentFrom, () => Promise.resolve().then(function () { return createAssetRentalHistoryRent_commands; }).then((m) => m.AXMCreateAssetRentalHistoryRentFromCommand)),
+            provideCommand(AXMAssetManagementCommandKeys.AssetRentalHistory.RentTo, () => Promise.resolve().then(function () { return createAssetRentalHistoryRent_commands; }).then((m) => m.AXMCreateAssetRentalHistoryRentToCommand)),
+            provideCommandSetups([
+                {
+                    key: AXMAssetManagementCommandKeys.WorkflowActivity.RecalculateOperationalStatus,
+                    command: () => import('./acorex-platform-module-asset-management-client-recalculate-asset-operational-status.activity-ueTauO_k.mjs').then((c) => c.RecalculateAssetOperationalStatusActivity),
+                },
+            ]),
+            // provideLazyProvider(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, () =>
+            //   import('./features/asset-status.rules').then((m) => m.AXMAssetManagementAssetStatusRulesExpressionScopeProvider),
+            // ),
+            // Status Providers
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return assetStatus_provider; }).then((m) => m.AXMAssetManagementAssetStatusProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-asset-management-client-asset-rental-history-status.provider-DwhQPb0-.mjs').then((m) => m.AXMAssetManagementAssetRentalHistoryStatusProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-asset-management-client-asset-lifecycle.provider-BDaCpGsv.mjs').then((m) => m.AXMAssetManagementAssetLifecycleStatusProvider)),
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: assetSystemTypeHasChildMiddleware,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: assetRentalHistoryPartyMiddleware,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: AssetManagementManifest,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMAssetManagementCatalogScopeDefinitionProvider,
+                            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)
+                        // Search Provider (lazy-loaded)
+                        provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMAssetManagementSearchCommandProvider)),
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => Promise.resolve().then(function () { return index; }).then((m) => m.AXMAssetTypeComponentsPageComponentProvider)),
+                        provideCommand('AssetType:Components:Save', () => Promise.resolve().then(function () { return saveAssetTypeComponents_command; }).then((m) => m.AXMSaveAssetTypeComponentsCommand)),
+                        provideCommand(AXMAssetManagementCommandKeys.AssetRentalHistory.RentFrom, () => Promise.resolve().then(function () { return createAssetRentalHistoryRent_commands; }).then((m) => m.AXMCreateAssetRentalHistoryRentFromCommand)),
+                        provideCommand(AXMAssetManagementCommandKeys.AssetRentalHistory.RentTo, () => Promise.resolve().then(function () { return createAssetRentalHistoryRent_commands; }).then((m) => m.AXMCreateAssetRentalHistoryRentToCommand)),
+                        provideCommandSetups([
+                            {
+                                key: AXMAssetManagementCommandKeys.WorkflowActivity.RecalculateOperationalStatus,
+                                command: () => import('./acorex-platform-module-asset-management-client-recalculate-asset-operational-status.activity-ueTauO_k.mjs').then((c) => c.RecalculateAssetOperationalStatusActivity),
+                            },
+                        ]),
+                        // provideLazyProvider(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, () =>
+                        //   import('./features/asset-status.rules').then((m) => m.AXMAssetManagementAssetStatusRulesExpressionScopeProvider),
+                        // ),
+                        // Status Providers
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => Promise.resolve().then(function () { return assetStatus_provider; }).then((m) => m.AXMAssetManagementAssetStatusProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-asset-management-client-asset-rental-history-status.provider-DwhQPb0-.mjs').then((m) => m.AXMAssetManagementAssetRentalHistoryStatusProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-asset-management-client-asset-lifecycle.provider-BDaCpGsv.mjs').then((m) => m.AXMAssetManagementAssetLifecycleStatusProvider)),
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: assetSystemTypeHasChildMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: assetRentalHistoryPartyMiddleware,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+//#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
+});
+
+//#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 = AXPAssetsMaintenancePermissionKeys;
+        const PLAN_EQUIPMENT_MENU_KEY = 'Configuration:Menu:PlantEquipment';
+        context.find(AXPCommonMenuKeys.PlantEquipment).addItems([
+            {
+                name: AXMAssetManagementMenuKeys.Assets,
+                text: '@asset-management:assets.menus.root.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.asset.name),
+                priority: 2,
+                icon: RootConfig.entities.asset.icon,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainAssets],
+                },
+            },
+            {
+                name: AXMAssetManagementMenuKeys.AssetSystems,
+                text: '@asset-management:assetSystems.menus.root.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.assetSystem.name),
+                priority: 3,
+                icon: RootConfig.entities.assetSystem.icon,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainAssets],
+                },
+            },
+        ]);
+        const mainAssetsMaintenanceDivider = context.find(AXMAssetManagementMenuKeys.MainPlanEquipmentAssetsMaintenanceDivider);
+        if (!mainAssetsMaintenanceDivider.exists) {
+            context.find(AXPCommonMenuKeys.PlantEquipment).addItems([
+                {
+                    name: AXMAssetManagementMenuKeys.MainPlanEquipmentAssetsMaintenanceDivider,
+                    text: '',
+                    type: 'break',
+                    priority: 10,
+                },
+            ]);
+        }
+        const planEquipmentMenu = context.find(PLAN_EQUIPMENT_MENU_KEY);
+        if (!planEquipmentMenu.exists) {
+            context.find(AXPCommonMenuKeys.Configuration).addItems([
+                {
+                    name: PLAN_EQUIPMENT_MENU_KEY,
+                    priority: 9000,
+                    text: '@general:menus.plan-equipment.title',
+                    icon: module.icon,
+                },
+            ]);
+        }
+        context.find(PLAN_EQUIPMENT_MENU_KEY).addItems([
+            {
+                name: AXMAssetManagementMenuKeys.AssetTypes,
+                text: '@asset-management:assetTypes.menus.root.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.assetType.name),
+                priority: 2,
+                icon: RootConfig.entities.assetType.icon,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.Setup],
+                },
+            },
+            {
+                name: AXMAssetManagementMenuKeys.AssetSystemTypes,
+                text: '@asset-management:assetSystemTypes.menus.root.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.assetSystemType.name),
+                priority: 3,
+                icon: RootConfig.entities.assetSystemType.icon,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.Setup],
+                },
+            },
+        ]);
+        const planEquipmentAssetsMaintenanceDivider = context.find(AXMAssetManagementMenuKeys.PlanEquipmentAssetsMaintenanceDivider);
+        if (!planEquipmentAssetsMaintenanceDivider.exists) {
+            context.find(PLAN_EQUIPMENT_MENU_KEY).addItems([
+                {
+                    name: AXMAssetManagementMenuKeys.PlanEquipmentAssetsMaintenanceDivider,
+                    text: '',
+                    type: 'break',
+                    priority: 10,
+                },
+            ]);
+        }
+    }
+}
+//#endregion
+
+var menu_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementMenuProvider: AXMAssetManagementMenuProvider
+});
+
+//#endregion
+//#region ----- Permission Definition Provider -----
+/**
+ * Registers Assets & Maintenance capabilities owned by asset-management.
+ */
+class AXMAssetManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPAssetsMaintenancePermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:assets-maintenance.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.AssetsMaintenance.Root, `${G}.assets-maintenance.title`, `${G}.assets-maintenance.description`, { order: 70 });
+        context
+            .addGroup(groups.AssetsMaintenance.Assets, `${G}.assets-maintenance-assets.title`, `${G}.assets-maintenance-assets.description`, { parent: groups.AssetsMaintenance.Root, order: 10 })
+            .addPermission(keys.Access, `${P}.access.title`, `${P}.access.description`)
+            .endPermission()
+            .addPermission(keys.MaintainAssets, `${P}.maintain-assets.title`, `${P}.maintain-assets.description`)
+            .endPermission()
+            .addPermission(keys.Setup, `${P}.setup.title`, `${P}.setup.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementPermissionDefinitionProvider: AXMAssetManagementPermissionDefinitionProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Search Command Provider   ----
+class AXMAssetManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                id: 'create-asset',
+                group: 'command',
+                title: '@asset-management:assets.search.create-asset.title',
+                icon: RootConfig.entities.asset.icon,
+                description: '@asset-management:assets.search.create-asset.description',
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.asset.name}`, {
+                        name: RootConfig.entities.asset.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.asset.title,
+                    }),
+                },
+            },
+        ];
+    }
+}
+//#endregion
+
+var searchCommand_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementSearchCommandProvider: AXMAssetManagementSearchCommandProvider
+});
+
+class AXMAssetManagementAssetStatusProvider extends AXPStatusProvider {
+    constructor() {
+        super(...arguments);
+        this.key = AXM_ASSET_STATUS_DEFINITION_KEY;
+        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.Assigned,
+                title: '@asset-management:assets.states.assigned',
+                icon: 'fa-light fa-user-check',
+                color: 'info',
+                order: 2,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.UnderMaintenanceInspection,
+                title: '@asset-management:assets.states.under-maintenance',
+                icon: 'fa-light fa-toolbox',
+                color: 'warning',
+                order: 3,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.OutOfService,
+                title: '@asset-management:assets.states.out-of-service',
+                icon: 'fa-light fa-triangle-exclamation',
+                color: 'danger',
+                order: 4,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+            {
+                name: AXMAssetStatus.Lost,
+                title: '@asset-management:assets.states.lost',
+                icon: 'fa-light fa-magnifying-glass-minus',
+                color: 'danger',
+                order: 5,
+                isInitial: false,
+                isFinal: false,
+                generateView: true,
+            },
+        ];
+        this.transitions = [
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Assigned,
+                title: '@asset-management:assets.transitions.assign',
+            },
+            {
+                from: AXMAssetStatus.Assigned,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.unassign',
+            },
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.UnderMaintenanceInspection,
+                title: '@asset-management:assets.transitions.start-maintenance',
+            },
+            {
+                from: AXMAssetStatus.Assigned,
+                to: AXMAssetStatus.UnderMaintenanceInspection,
+                title: '@asset-management:assets.transitions.start-maintenance',
+            },
+            {
+                from: AXMAssetStatus.OutOfService,
+                to: AXMAssetStatus.UnderMaintenanceInspection,
+                title: '@asset-management:assets.transitions.start-maintenance',
+            },
+            {
+                from: AXMAssetStatus.UnderMaintenanceInspection,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.release-as-available',
+            },
+            {
+                from: AXMAssetStatus.UnderMaintenanceInspection,
+                to: AXMAssetStatus.Assigned,
+                title: '@asset-management:assets.transitions.restore-assignment',
+            },
+            {
+                from: AXMAssetStatus.UnderMaintenanceInspection,
+                to: AXMAssetStatus.OutOfService,
+                title: '@asset-management:assets.transitions.keep-out-of-service',
+            },
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.OutOfService,
+                title: '@asset-management:assets.transitions.mark-out-of-service',
+            },
+            {
+                from: AXMAssetStatus.Assigned,
+                to: AXMAssetStatus.OutOfService,
+                title: '@asset-management:assets.transitions.mark-out-of-service',
+            },
+            {
+                from: AXMAssetStatus.OutOfService,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.restore-service',
+            },
+            {
+                from: AXMAssetStatus.OutOfService,
+                to: AXMAssetStatus.Assigned,
+                title: '@asset-management:assets.transitions.restore-service',
+            },
+            {
+                from: AXMAssetStatus.Available,
+                to: AXMAssetStatus.Lost,
+                title: '@asset-management:assets.transitions.mark-lost',
+            },
+            {
+                from: AXMAssetStatus.Assigned,
+                to: AXMAssetStatus.Lost,
+                title: '@asset-management:assets.transitions.mark-lost',
+            },
+            {
+                from: AXMAssetStatus.OutOfService,
+                to: AXMAssetStatus.Lost,
+                title: '@asset-management:assets.transitions.mark-lost',
+            },
+            {
+                from: AXMAssetStatus.UnderMaintenanceInspection,
+                to: AXMAssetStatus.Lost,
+                title: '@asset-management:assets.transitions.mark-lost',
+            },
+            {
+                from: AXMAssetStatus.Lost,
+                to: AXMAssetStatus.Available,
+                title: '@asset-management:assets.transitions.found',
+            },
+            {
+                from: AXMAssetStatus.Lost,
+                to: AXMAssetStatus.Assigned,
+                title: '@asset-management:assets.transitions.found',
+            },
+            {
+                from: AXMAssetStatus.Lost,
+                to: AXMAssetStatus.OutOfService,
+                title: '@asset-management:assets.transitions.found-out-of-service',
+            },
+        ];
+        // readonly transitions: AXPStatusTransition[] = [
+        //   {
+        //     from: AXMAssetStatus.Available,
+        //     to: AXMAssetStatus.Assigned,
+        //     title: '@asset-management:assets.transitions.assign',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Assigned,
+        //     to: AXMAssetStatus.Available,
+        //     title: '@asset-management:assets.transitions.unassign',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Assigned,
+        //     to: AXMAssetStatus.UnderMaintenanceInspection,
+        //     title: '@asset-management:assets.transitions.start-maintenance',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Assigned,
+        //     to: AXMAssetStatus.OutOfService,
+        //     title: '@asset-management:assets.transitions.mark-out-of-service',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Available,
+        //     to: AXMAssetStatus.UnderMaintenanceInspection,
+        //     title: '@asset-management:assets.transitions.start-maintenance',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.OutOfService,
+        //     to: AXMAssetStatus.UnderMaintenanceInspection,
+        //     title: '@asset-management:assets.transitions.start-maintenance',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.UnderMaintenanceInspection,
+        //     to: AXMAssetStatus.Available,
+        //     title: '@asset-management:assets.transitions.complete-maintenance',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Available,
+        //     to: AXMAssetStatus.OutOfService,
+        //     title: '@asset-management:assets.transitions.mark-out-of-service',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.OutOfService,
+        //     to: AXMAssetStatus.Available,
+        //     title: '@asset-management:assets.transitions.restore-service',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Available,
+        //     to: AXMAssetStatus.Lost,
+        //     title: '@asset-management:assets.transitions.mark-lost',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Assigned,
+        //     to: AXMAssetStatus.Lost,
+        //     title: '@asset-management:assets.transitions.mark-lost',
+        //   },
+        //   {
+        //     from: AXMAssetStatus.Lost,
+        //     to: AXMAssetStatus.Available,
+        //     title: '@asset-management:assets.transitions.found',
+        //   },
+        // ];
+        this.defaultStatus = AXMAssetStatus.Available;
+    }
+}
+
+var assetStatus_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetManagementAssetStatusProvider: AXMAssetManagementAssetStatusProvider
+});
+
+const rentalHistorySharedCreateFields = [
+    'rentalDirection',
+    'createdDate',
+    'startDate',
+    'monthlyRent',
+    'expectedReturnDate',
+    'actualReturnDate',
+    'status',
+    'description',
+];
+//#endregion
+//#region ----   Helpers   ----
+function buildRentCreateOptions(direction) {
+    const isRentFrom = direction === 'rentFrom';
+    return {
+        includeProperties: [
+            ...rentalHistorySharedCreateFields,
+            isRentFrom ? 'rentedFromId' : 'rentedToId',
+        ],
+        excludeProperties: [isRentFrom ? 'rentedToId' : 'rentedFromId'],
+        decoration: {
+            header: {
+                title: isRentFrom
+                    ? '@asset-management:assetRentalHistories.entities.assetRentalHistory.actions.rent-from.dialog-title'
+                    : '@asset-management:assetRentalHistories.entities.assetRentalHistory.actions.rent-to.dialog-title',
+            },
+        },
+        process: {
+            redirect: false,
+            canCreateNewOne: true,
+        },
+    };
+}
+//#endregion
+//#region ----   Commands   ----
+class AXMCreateAssetRentalHistoryRentCommandBase {
+    constructor() {
+        this.commandService = inject(AXPCommandService);
+    }
+    async execute(input) {
+        const seedData = this.resolveSeedData(input);
+        const createOptions = buildRentCreateOptions(this.rentalDirection);
+        const result = await this.commandService.execute('Entity:Create', {
+            entity: RootConfig.entities.assetRentalHistory.source,
+            entityInfo: {
+                name: RootConfig.entities.assetRentalHistory.name,
+                module: RootConfig.module.name,
+                title: RootConfig.entities.assetRentalHistory.title,
+            },
+            data: seedData,
+            options: createOptions,
+        });
+        return result ?? { success: false };
+    }
+    resolveSeedData(input) {
+        const ctx = input;
+        const options = (input.options ?? ctx.options ?? {});
+        const process = (options['process'] ?? {});
+        const processData = process['data'];
+        const contextData = ctx.data ?? input.data ?? {};
+        return merge({}, typeof contextData === 'object' &&
+            contextData !== null &&
+            !Array.isArray(contextData)
+            ? contextData
+            : {}, typeof processData === 'object' &&
+            processData !== null &&
+            !Array.isArray(processData)
+            ? processData
+            : {}, { rentalDirection: this.rentalDirection });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentCommandBase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentCommandBase, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentCommandBase, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class AXMCreateAssetRentalHistoryRentFromCommand extends AXMCreateAssetRentalHistoryRentCommandBase {
+    constructor() {
+        super(...arguments);
+        this.rentalDirection = 'rentFrom';
+    }
+    static { this.commandKey = AXMAssetManagementCommandKeys.AssetRentalHistory.RentFrom; }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentFromCommand, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentFromCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentFromCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class AXMCreateAssetRentalHistoryRentToCommand extends AXMCreateAssetRentalHistoryRentCommandBase {
+    constructor() {
+        super(...arguments);
+        this.rentalDirection = 'rentTo';
+    }
+    static { this.commandKey = AXMAssetManagementCommandKeys.AssetRentalHistory.RentTo; }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentToCommand, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentToCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateAssetRentalHistoryRentToCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var createAssetRentalHistoryRent_commands = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMCreateAssetRentalHistoryRentFromCommand: AXMCreateAssetRentalHistoryRentFromCommand,
+    AXMCreateAssetRentalHistoryRentToCommand: AXMCreateAssetRentalHistoryRentToCommand
+});
+
+function normalizeAssetTypeBuilderLocalizedField(value, fallback) {
+    if (value == null || value === '') {
+        return fallback;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || fallback;
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const record = value;
+        const anyLocaleText = Object.values(record).some((v) => typeof v === 'string' && String(v).trim() !== '');
+        if (anyLocaleText) {
+            return value;
+        }
+    }
+    return fallback;
+}
+function createAssetTypeSectionBuilderDefaultValue(assetTypeId) {
+    return {
+        sections: [
+            {
+                id: AXPDataGenerator.uuid(),
+                code: 1,
+                title: 'New Section',
+                assetTypeId: assetTypeId ?? '',
+                description: '',
+                items: [],
+            },
+        ],
+    };
+}
+function normalizeAssetTypeSectionBuilderValue(value, assetTypeId) {
+    if (!value || typeof value !== 'object') {
+        return createAssetTypeSectionBuilderDefaultValue(assetTypeId);
+    }
+    const raw = value;
+    if (!Array.isArray(raw.sections) || raw.sections.length === 0) {
+        return createAssetTypeSectionBuilderDefaultValue(assetTypeId);
+    }
+    return {
+        sections: raw.sections.map((section, sectionIndex) => {
+            const sectionData = (section ?? {});
+            const id = typeof sectionData.id === 'string' && sectionData.id ? sectionData.id : AXPDataGenerator.uuid();
+            const sectionItems = Array.isArray(sectionData.items) ? sectionData.items : [];
+            return {
+                id,
+                code: typeof sectionData.code === 'number' ? sectionData.code : sectionIndex + 1,
+                title: normalizeAssetTypeBuilderLocalizedField(sectionData.title, `Section ${sectionIndex + 1}`),
+                assetTypeId: typeof sectionData.assetTypeId === 'string' && sectionData.assetTypeId
+                    ? sectionData.assetTypeId
+                    : assetTypeId ?? '',
+                description: normalizeAssetTypeBuilderLocalizedField(sectionData.description, ''),
+                items: sectionItems.map((item, itemIndex) => {
+                    const itemData = (item ?? {});
+                    const rawAt = itemData.assetType;
+                    const assetTypeIdFromRef = rawAt &&
+                        typeof rawAt === 'object' &&
+                        typeof rawAt.id === 'string' &&
+                        String(rawAt.id).trim()
+                        ? String(rawAt.id).trim()
+                        : '';
+                    const normalizedAssetTypeId = typeof itemData.assetTypeId === 'string' && itemData.assetTypeId.trim()
+                        ? itemData.assetTypeId.trim()
+                        : assetTypeIdFromRef || (assetTypeId ?? '');
+                    const assetTypeRef = rawAt && typeof rawAt === 'object'
+                        ? {
+                            id: typeof rawAt.id === 'string' && String(rawAt.id).trim()
+                                ? String(rawAt.id).trim()
+                                : normalizedAssetTypeId,
+                            name: normalizeAssetTypeBuilderLocalizedField(rawAt.name, ''),
+                        }
+                        : {
+                            id: normalizedAssetTypeId,
+                            name: '',
+                        };
+                    return {
+                        id: typeof itemData.id === 'string' && itemData.id ? itemData.id : AXPDataGenerator.uuid(),
+                        assetTypeSectionId: typeof itemData.assetTypeSectionId === 'string' && itemData.assetTypeSectionId
+                            ? itemData.assetTypeSectionId
+                            : id,
+                        assetTypeSectionComponentId: typeof itemData.assetTypeSectionComponentId === 'string' && itemData.assetTypeSectionComponentId
+                            ? itemData.assetTypeSectionComponentId
+                            : undefined,
+                        assetTypeId: normalizedAssetTypeId,
+                        assetType: assetTypeRef,
+                        assetTypeSection: itemData.assetTypeSection,
+                        roleName: normalizeAssetTypeBuilderLocalizedField(itemData.roleName, ''),
+                        count: typeof itemData.count === 'number' ? itemData.count : 1,
+                        hasMaintenance: itemData.hasMaintenance === true,
+                        assetId: typeof itemData.assetId === 'string' && itemData.assetId ? itemData.assetId : undefined,
+                        asset: itemData.asset && typeof itemData.asset === 'object'
+                            ? {
+                                id: typeof itemData.asset.id === 'string'
+                                    ? (itemData.asset.id ?? '')
+                                    : '',
+                                code: typeof itemData.asset.code === 'string'
+                                    ? itemData.asset.code
+                                    : undefined,
+                                title: normalizeAssetTypeBuilderLocalizedField(itemData.asset.title, ''),
+                            }
+                            : undefined,
+                    };
+                }),
+            };
+        }),
+    };
+}
+
+class AXMAssetTypeSectionBuilderComponent {
+    constructor() {
+        this.value = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        this.assetTypeId = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assetTypeId" }] : /* istanbul ignore next */ []));
+        this.options = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
+        this.valueChange = output();
+        this.standardRef = viewChild(AXPStandardSectionItemsBuilderComponent, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "standardRef" }] : /* istanbul ignore next */ []));
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+        this.disabledSectionPrompt = false;
+        this.disabledAddSectionPrompt = async () => null;
+        this.builderValue = signal({ sections: [] }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderValue" }] : /* istanbul ignore next */ []));
+        this.standardConfig = computed(() => ({
+            mapItemToView: (item, _section) => this.mapItemToView(item),
+            promptAddSection: this.allowAddSection() ? (value) => this.promptAddSection(value) : this.disabledAddSectionPrompt,
+            promptEditSection: this.allowEditSection()
+                ? (section, value) => this.promptEditSection(section, value)
+                : this.disabledSectionPrompt,
+            promptAddItems: this.allowAddItems() ? (sectionId, value) => this.promptAddItems(sectionId, value) : undefined,
+            promptEditItem: (item, sectionId, value) => this.linkAssetMode()
+                ? this.promptEditLinkedAssetItem(item, sectionId, value)
+                : this.promptEditItem(item, sectionId, value),
+            confirmRemoveSection: this.linkAssetMode() ? async () => false : undefined,
+            confirmRemoveItem: this.linkAssetMode()
+                ? (item, sectionId) => this.confirmRemoveLinkedAssetItem(item, sectionId)
+                : undefined,
+            showSectionTechnicalName: false,
+            allowReorderSections: this.allowReorderSections(),
+            minSectionCount: this.allowAddSection() ? 1 : Number.MAX_SAFE_INTEGER,
+            texts: {
+                addSection: '@asset-management:assetTypeSections.entities.assetTypeSection.actions.add-section.title',
+                addItem: '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.actions.add-item.title',
+            },
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "standardConfig" }] : /* istanbul ignore next */ []));
+        this.hideHeaderActions = computed(() => this.options()['hideHeaderActions'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hideHeaderActions" }] : /* istanbul ignore next */ []));
+        this.allowAddSection = computed(() => this.options()['allowAddSection'] !== false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddSection" }] : /* istanbul ignore next */ []));
+        this.allowEditSection = computed(() => {
+            if (this.linkAssetMode()) {
+                return false;
+            }
+            return this.options()['allowEditSection'] !== false;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowEditSection" }] : /* istanbul ignore next */ []));
+        this.allowAddItems = computed(() => this.options()['allowAddItems'] !== false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddItems" }] : /* istanbul ignore next */ []));
+        this.allowReorderSections = computed(() => {
+            const option = this.options()['allowReorderSections'];
+            return typeof option === 'boolean' ? option : true;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowReorderSections" }] : /* istanbul ignore next */ []));
+        this.readonly = computed(() => this.options()['readonly'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        this.linkAssetMode = computed(() => this.options()['linkAssetMode'] === true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "linkAssetMode" }] : /* istanbul ignore next */ []));
+        this.#syncValueToBuilder = effect(() => {
+            const normalized = normalizeAssetTypeSectionBuilderValue(this.value(), this.assetTypeId());
+            this.builderValue.set(this.toBuilderValue(normalized));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncValueToBuilder" }] : /* istanbul ignore next */ []));
+    }
+    #syncValueToBuilder;
+    async addSection() {
+        await this.standardRef()?.addSection();
+    }
+    /** Aligns section-items baseline to persisted value after save. */
+    syncAfterSave(value) {
+        const normalized = normalizeAssetTypeSectionBuilderValue(value, this.assetTypeId());
+        this.builderValue.set(this.toBuilderValue(normalized));
+        queueMicrotask(() => this.standardRef()?.markClean());
+    }
+    /** Re-applies the current `[value]` input and clears builder dirty state after discard. */
+    resetAfterDiscard() {
+        const normalized = normalizeAssetTypeSectionBuilderValue(this.value(), this.assetTypeId());
+        this.builderValue.set(this.toBuilderValue(normalized));
+        queueMicrotask(() => this.standardRef()?.markClean());
+    }
+    onBuilderValueChange(next) {
+        this.builderValue.set(next);
+        const value = this.fromBuilderValue(next);
+        this.valueChange.emit(value);
+    }
+    async promptAddSection(value) {
+        const seed = {
+            code: this.getNextSectionCode(value),
+            title: '',
+            description: '',
+        };
+        const dialogValue = await this.promptSectionForm('create', seed, value);
+        if (!dialogValue)
+            return null;
+        const sectionId = AXPDataGenerator.uuid();
+        return {
+            id: sectionId,
+            name: sectionId,
+            code: dialogValue.code,
+            title: dialogValue.title,
+            description: dialogValue.description,
+        };
+    }
+    async promptEditSection(section, value) {
+        const seed = {
+            code: Number(section['code'] ?? 0) || this.getNextSectionCode(value),
+            title: this.resolveLocalizedTextForDialog(section['title']),
+            description: this.resolveLocalizedTextForDialog(section['description']),
+        };
+        const dialogValue = await this.promptSectionForm('edit', seed, value, section.id);
+        if (!dialogValue)
+            return null;
+        return {
+            ...section,
+            code: dialogValue.code,
+            title: dialogValue.title,
+            description: dialogValue.description,
+        };
+    }
+    async promptSectionForm(mode, seed, value, currentSectionId) {
+        const title = mode === 'create'
+            ? (await this.translationService.translateAsync('@asset-management:assetTypeSections.entities.assetTypeSection.actions.add-section.title')) || 'Add Section'
+            : (await this.translationService.translateAsync('@general:actions.edit.title')) || 'Edit';
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(title)
+                .setSize('sm')
+                .setCloseButton(true)
+                .setContext({ ...seed })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(this.buildSectionFormDefinition());
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const code = Number(context.code ?? 0);
+                const titleValue = String(context.title ?? '').trim();
+                const description = String(context.description ?? '');
+                if (!Number.isFinite(code) || code <= 0 || !titleValue) {
+                    return { success: false };
+                }
+                if (this.isDuplicateSectionCode(value, code, currentSectionId)) {
+                    return { success: false };
+                }
+                return { success: true, kind: 'object', value: {
+                        code,
+                        title: titleValue,
+                        description,
+                    },
+                };
+            });
+        })
+            .show();
+        return result?.success && result.value ? result.value : null;
+    }
+    isDuplicateSectionCode(value, code, currentSectionId) {
+        return value.sections.some((section) => {
+            if (currentSectionId && section.id === currentSectionId)
+                return false;
+            const sectionCode = Number(section['code'] ?? 0);
+            return Number.isFinite(sectionCode) && sectionCode === code;
+        });
+    }
+    getNextSectionCode(value) {
+        const maxCode = value.sections.reduce((max, section) => {
+            const sectionCode = Number(section['code'] ?? 0);
+            if (!Number.isFinite(sectionCode))
+                return max;
+            return Math.max(max, sectionCode);
+        }, 0);
+        return maxCode + 1;
+    }
+    mapItemToView(item) {
+        const roleName = this.resolveLocalizedTextForDialog(item['roleName'] ?? '');
+        const assetTypeName = this.resolveLocalizedTextForDialog(item['assetType']?.name ?? '');
+        const count = Number(item['count'] ?? 0);
+        const hasMaintenance = item['hasMaintenance'] === true;
+        const linkedAsset = item['asset'];
+        const linkedAssetCode = typeof linkedAsset?.code === 'string' ? linkedAsset.code : '';
+        const linkedAssetTitle = this.resolveLocalizedTextForDialog(linkedAsset?.title ?? '');
+        if (this.linkAssetMode()) {
+            const hasLinkedAsset = !!item['assetId'];
+            const linkedAssetName = linkedAssetTitle || '@asset-management:assets.entities.asset.components.asset-component.no-link';
+            const linkedAssetDisplay = linkedAssetCode ? `${linkedAssetName} (${linkedAssetCode})` : linkedAssetName;
+            return {
+                icon: hasLinkedAsset ? 'fa-light fa-link' : 'fa-light fa-link-slash',
+                iconTone: hasLinkedAsset ? 'easy' : 'hard',
+                title: roleName,
+                name: linkedAssetDisplay,
+                badges: [
+                    {
+                        text: hasLinkedAsset
+                            ? '@asset-management:assets.entities.asset.components.asset-component.assigned'
+                            : '@asset-management:assets.entities.asset.components.asset-component.unassigned',
+                        variant: hasLinkedAsset ? 'success' : 'warning',
+                    },
+                    ...(hasLinkedAsset && linkedAssetTitle
+                        ? [
+                            {
+                                text: linkedAssetTitle,
+                                variant: 'neutral',
+                            },
+                        ]
+                        : []),
+                    {
+                        text: assetTypeName,
+                        variant: 'neutral',
+                    },
+                ],
+            };
+        }
+        return {
+            icon: 'fa-light fa-cube',
+            title: roleName,
+            name: assetTypeName,
+            badges: [
+                {
+                    text: `x${count}`,
+                    variant: 'neutral',
+                },
+                ...(hasMaintenance
+                    ? [
+                        {
+                            text: '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.fields.hasMaintenance.title',
+                            variant: 'success',
+                        },
+                    ]
+                    : []),
+            ],
+        };
+    }
+    async promptAddItems(sectionId, value) {
+        const section = value.sections.find((item) => item.id === sectionId);
+        if (!section)
+            return null;
+        const itemValue = await this.promptItemForm('create');
+        if (!itemValue)
+            return null;
+        const nextOrder = section.items.length;
+        const id = AXPDataGenerator.uuid();
+        return [
+            {
+                id,
+                order: nextOrder,
+                name: itemValue.assetType.name,
+                roleName: itemValue.roleName,
+                count: itemValue.count,
+                hasMaintenance: itemValue.hasMaintenance,
+                assetType: itemValue.assetType,
+                assetTypeSectionId: section.id,
+                assetTypeId: itemValue.assetTypeId || this.assetTypeId() || '',
+            },
+        ];
+    }
+    async promptEditItem(item, _sectionId, _value) {
+        const dialogValue = await this.promptItemForm('edit', {
+            assetTypeId: String(item['assetTypeId'] ?? this.assetTypeId() ?? ''),
+            assetType: item['assetType'] ?? {
+                id: String(item['assetTypeId'] ?? this.assetTypeId() ?? ''),
+                name: '',
+            },
+            roleName: this.resolveLocalizedTextForDialog(item['roleName'] ?? item['name'] ?? ''),
+            count: Number(item['count'] ?? 1),
+            hasMaintenance: item['hasMaintenance'] === true,
+        });
+        if (!dialogValue)
+            return null;
+        return {
+            ...item,
+            name: dialogValue.assetType.name,
+            roleName: dialogValue.roleName,
+            count: dialogValue.count,
+            hasMaintenance: dialogValue.hasMaintenance,
+            assetTypeId: dialogValue.assetTypeId,
+            assetType: dialogValue.assetType,
+        };
+    }
+    async promptEditLinkedAssetItem(item, _sectionId, _value) {
+        const seed = {
+            assetId: String(item['assetId'] ?? ''),
+            assetTypeId: String(item['assetTypeId'] ?? '').trim(),
+            asset: item['asset'] ?? {
+                id: '',
+                code: '',
+                title: '',
+            },
+        };
+        const result = await this.promptLinkAssetForm(seed);
+        if (!result) {
+            return null;
+        }
+        return {
+            ...item,
+            assetId: result.assetId || undefined,
+            asset: result.assetId ? result.asset : undefined,
+        };
+    }
+    async promptLinkAssetForm(seed) {
+        const title = (await this.translationService.translateAsync('@asset-management:assets.entities.asset.components.asset-component.actions.edit.title')) || 'Edit Component Asset';
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(title)
+                .setSize('sm')
+                .setCloseButton(true)
+                .setContext({ ...seed })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(this.buildLinkAssetFormDefinition());
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const assetId = String(context.assetId ?? '').trim();
+                const asset = context.asset ?? { id: assetId, code: '', title: '' };
+                return { success: true, kind: 'object', value: {
+                        assetId,
+                        assetTypeId: String(context.assetTypeId ?? ''),
+                        asset: {
+                            id: String(asset.id ?? assetId),
+                            code: String(asset.code ?? ''),
+                            title: String(asset.title ?? ''),
+                        },
+                    },
+                };
+            });
+        })
+            .show();
+        return result?.success && result.value ? result.value : null;
+    }
+    async confirmRemoveLinkedAssetItem(item, sectionId) {
+        const hasLinkedAsset = typeof item['assetId'] === 'string' && item['assetId'].length > 0;
+        if (!hasLinkedAsset) {
+            return false;
+        }
+        const deleteTitle = (await this.translationService.translateAsync('@asset-management:assets.entities.asset.components.asset-component.actions.delete.title')) || 'Remove Component Asset';
+        const linkedAsset = item['asset'];
+        const linkedAssetTitle = this.resolveLocalizedTextForDialog(linkedAsset?.title ?? '');
+        const linkedAssetCode = typeof linkedAsset?.code === 'string' ? linkedAsset.code : '';
+        const assetDisplay = linkedAssetTitle || linkedAssetCode || String(item['assetId'] ?? '');
+        const assetLabel = `${assetDisplay}${linkedAssetCode && linkedAssetTitle ? ` (${linkedAssetCode})` : ''}`;
+        const deleteResult = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(deleteTitle)
+                .setMessage('@general:workflow.confirm-delete')
+                .setSize('sm')
+                .setCloseButton(true)
+                .setContext({ assetLabel })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(this.buildRemoveLinkedAssetFormDefinition());
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').custom({
+                    title: '@general:actions.delete.title',
+                    color: 'danger',
+                    command: {
+                        name: 'delete',
+                        options: {
+                            validate: false,
+                        },
+                    },
+                });
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() !== 'delete') {
+                    return { success: false };
+                }
+                return { success: true, kind: 'object', data: undefined };
+            });
+        })
+            .show();
+        if (deleteResult?.success === true) {
+            this.unlinkLinkedAssetItem(item.id, sectionId);
+        }
+        // Prevent structural row removal; only unlink asset assignment.
+        return false;
+    }
+    buildRemoveLinkedAssetFormDefinition() {
+        const group = {
+            name: 'unlink-asset',
+            title: '@asset-management:assets.entities.asset.components.asset-component.title',
+            parameters: [
+                {
+                    path: 'assetLabel',
+                    title: '@asset-management:assets.entities.asset.title',
+                    widget: {
+                        path: 'assetLabel',
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            disabled: true,
+                        },
+                    },
+                },
+            ],
+        };
+        return { groups: [group] };
+    }
+    unlinkLinkedAssetItem(itemId, sectionId) {
+        const nextValue = {
+            sections: this.builderValue().sections.map((section) => {
+                if (section.id !== sectionId) {
+                    return section;
+                }
+                return {
+                    ...section,
+                    items: section.items.map((item) => {
+                        if (item.id !== itemId) {
+                            return item;
+                        }
+                        return {
+                            ...item,
+                            assetId: undefined,
+                            asset: undefined,
+                        };
+                    }),
+                };
+            }),
+        };
+        this.onBuilderValueChange(nextValue);
+    }
+    async promptItemForm(mode, seed) {
+        const defaultSeed = seed ?? {
+            assetTypeId: '',
+            assetType: {
+                id: '',
+                name: '',
+            },
+            roleName: '',
+            count: 1,
+            hasMaintenance: false,
+        };
+        const title = mode === 'create'
+            ? (await this.translationService.translateAsync('@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.actions.add-item.title')) || 'Add Component'
+            : (await this.translationService.translateAsync('@general:actions.edit.title')) || 'Edit';
+        const formDefinition = this.buildItemFormDefinition();
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(title)
+                .setSize('sm')
+                .setCloseButton(true)
+                .setContext({ ...defaultSeed })
+                .content((layout) => {
+                layout.mode('edit');
+                layout.dynamicForm(formDefinition);
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.save.title');
+            })
+                .onAction((dialogRef) => {
+                if (dialogRef.action() === 'cancel') {
+                    return { success: false };
+                }
+                const context = dialogRef.context();
+                const assetTypeId = String(context.assetTypeId ?? '').trim();
+                const assetType = context.assetType;
+                const roleName = String(context.roleName ?? '').trim();
+                const count = Number(context.count ?? 0);
+                const hasMaintenance = context.hasMaintenance === true;
+                if (!assetTypeId) {
+                    return { success: false };
+                }
+                return { success: true, kind: 'object', value: {
+                        assetTypeId,
+                        assetType: {
+                            id: String(assetType?.id ?? assetTypeId),
+                            name: String(assetType?.name ?? ''),
+                        },
+                        roleName,
+                        count: Number.isFinite(count) && count > 0 ? count : 1,
+                        hasMaintenance,
+                    },
+                };
+            });
+        })
+            .show();
+        return result?.success && result.value ? result.value : null;
+    }
+    buildItemFormDefinition() {
+        const excludedAssetTypeId = this.assetTypeId();
+        const group = {
+            name: 'component',
+            title: '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.title',
+            parameters: [
+                {
+                    path: 'assetTypeId',
+                    title: '@asset-management:assetTypes.entities.assetType.title',
+                    widget: {
+                        path: 'assetTypeId',
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.assetType.name}`,
+                            textField: 'title',
+                            valueField: 'id',
+                            look: 'select',
+                            multiple: false,
+                            expose: [
+                                { source: 'id', target: 'assetType.id' },
+                                { source: 'title', target: 'assetType.name' },
+                                { source: 'hasMaintenance', target: 'hasMaintenance' },
+                            ],
+                            ...(excludedAssetTypeId
+                                ? {
+                                    filter: { field: 'id', operator: { type: 'notEqual' }, value: excludedAssetTypeId },
+                                }
+                                : {}),
+                            validations: [{ rule: 'required' }],
+                        },
+                    },
+                },
+                this.toFieldDefinition('hasMaintenance', '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.fields.hasMaintenance.title', AXPWidgetsCatalog.toggle),
+                this.toFieldDefinition('count', '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.fields.count.title', AXPWidgetsCatalog.number, [{ rule: 'required' }]),
+                this.toFieldDefinition('roleName', '@asset-management:assetTypeSectionComponents.entities.assetTypeSectionComponent.fields.roleName.title', AXPWidgetsCatalog.largeText),
+            ],
+        };
+        return { groups: [group] };
+    }
+    buildSectionFormDefinition() {
+        const group = {
+            name: 'section',
+            title: '@asset-management:assetTypeSections.entities.assetTypeSection.title',
+            parameters: [
+                this.toFieldDefinition('code', '@asset-management:assetTypeSections.entities.assetTypeSection.fields.code.title', AXPWidgetsCatalog.number, [{ rule: 'required' }]),
+                this.toFieldDefinition('title', '@asset-management:assetTypeSections.entities.assetTypeSection.fields.title.title', AXPWidgetsCatalog.text, [{ rule: 'required' }]),
+                this.toFieldDefinition('description', '@asset-management:assetTypeSections.entities.assetTypeSection.fields.description.title', AXPWidgetsCatalog.largeText),
+            ],
+        };
+        return { groups: [group] };
+    }
+    buildLinkAssetFormDefinition() {
+        const currentAssetId = this.options()['mainAssetId'];
+        const filters = [
+            ...(typeof currentAssetId === 'string' && currentAssetId
+                ? [{ field: 'id', operator: { type: 'notEqual' }, value: currentAssetId }]
+                : []),
+            {
+                field: 'assetTypeId',
+                operator: { type: 'equal' },
+                value: "{{ context.eval('assetTypeId') }}",
+            },
+        ];
+        const group = {
+            name: 'asset-link',
+            title: '@asset-management:assets.entities.asset.title',
+            parameters: [
+                {
+                    path: 'assetId',
+                    title: '@asset-management:assets.entities.asset.title',
+                    widget: {
+                        path: 'assetId',
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.asset.name}`,
+                            textField: 'title',
+                            valueField: 'id',
+                            look: 'lookup',
+                            allowSearch: true,
+                            hasClearButton: true,
+                            columns: ['code', 'title', 'assetTypeId', 'statusId', 'locationId'],
+                            expose: [
+                                { source: 'id', target: 'asset.id' },
+                                { source: 'code', target: 'asset.code' },
+                                { source: 'title', target: 'asset.title' },
+                            ],
+                            filter: filters.length === 1 ? filters[0] : { logic: 'and', filters },
+                            validations: [{ rule: 'required' }],
+                        },
+                    },
+                },
+            ],
+        };
+        return { groups: [group] };
+    }
+    toFieldDefinition(path, title, widgetType, validations = []) {
+        return {
+            path,
+            title,
+            widget: {
+                path,
+                type: widgetType,
+                ...(validations.length > 0 ? { options: { validations } } : {}),
+            },
+        };
+    }
+    toBuilderValue(value) {
+        return {
+            sections: value.sections.map((section) => ({
+                id: section.id,
+                order: section.code - 1,
+                name: section.id,
+                code: section.code,
+                title: section.title,
+                description: section.description,
+                items: section.items.map((item, itemIndex) => ({
+                    id: item.id,
+                    order: itemIndex,
+                    name: this.resolveLocalizedTextForDialog(item.assetType?.name ?? ''),
+                    assetType: item.assetType,
+                    roleName: item.roleName,
+                    count: item.count,
+                    hasMaintenance: item.hasMaintenance,
+                    assetTypeId: item.assetTypeId,
+                    assetTypeSectionId: item.assetTypeSectionId || section.id,
+                    assetTypeSectionComponentId: item.assetTypeSectionComponentId || item.id,
+                    assetId: item.assetId,
+                    asset: item.asset,
+                })),
+            })),
+        };
+    }
+    fromBuilderValue(value) {
+        const assetTypeId = this.assetTypeId() ?? '';
+        return {
+            sections: value.sections.map((section, sectionIndex) => {
+                const sectionId = section.id || AXPDataGenerator.uuid();
+                const sectionCodeRaw = Number(section['code'] ?? sectionIndex + 1);
+                const sectionCode = Number.isFinite(sectionCodeRaw) && sectionCodeRaw > 0 ? sectionCodeRaw : sectionIndex + 1;
+                return {
+                    id: sectionId,
+                    code: sectionCode,
+                    title: normalizeAssetTypeBuilderLocalizedField(section['title'], `Section ${sectionCode}`),
+                    assetTypeId,
+                    description: normalizeAssetTypeBuilderLocalizedField(section['description'], ''),
+                    items: section.items.map((item) => this.mapBuilderItemToDomain(item, sectionId, assetTypeId)),
+                };
+            }),
+        };
+    }
+    mapBuilderItemToDomain(item, sectionId, assetTypeId) {
+        const rawAt = item['assetType'];
+        const normalizedAssetTypeId = (() => {
+            const fromField = typeof item['assetTypeId'] === 'string' ? String(item['assetTypeId']).trim() : '';
+            if (fromField)
+                return fromField;
+            const fromRef = typeof rawAt?.id === 'string' ? String(rawAt.id).trim() : '';
+            if (fromRef)
+                return fromRef;
+            return String(assetTypeId ?? '');
+        })();
+        return {
+            id: item.id || AXPDataGenerator.uuid(),
+            assetTypeSectionId: String(item['assetTypeSectionId'] ?? sectionId),
+            assetTypeId: normalizedAssetTypeId,
+            assetType: {
+                id: String(rawAt?.id ?? normalizedAssetTypeId),
+                name: normalizeAssetTypeBuilderLocalizedField(rawAt?.name, ''),
+            },
+            roleName: normalizeAssetTypeBuilderLocalizedField(item['roleName'], ''),
+            count: Number(item['count'] ?? 1),
+            hasMaintenance: item['hasMaintenance'] === true,
+            assetTypeSectionComponentId: String(item['assetTypeSectionComponentId'] ?? ''),
+            assetId: typeof item['assetId'] === 'string' ? item['assetId'] : undefined,
+            asset: item['asset'] && typeof item['asset'] === 'object'
+                ? {
+                    id: String(item['asset'].id ?? ''),
+                    code: typeof item['asset'].code === 'string'
+                        ? (item['asset'].code ?? '')
+                        : undefined,
+                    title: normalizeAssetTypeBuilderLocalizedField(item['asset'].title, ''),
+                }
+                : undefined,
+        };
+    }
+    resolveLocalizedTextForDialog(value) {
+        if (value == null || value === '') {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        return resolveMultiLanguageString(value, this.translationService.getActiveLang());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeSectionBuilderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMAssetTypeSectionBuilderComponent, isStandalone: true, selector: "axm-asset-type-section-builder", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, assetTypeId: { classPropertyName: "assetTypeId", publicName: "assetTypeId", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueChange: "valueChange" }, viewQueries: [{ propertyName: "standardRef", first: true, predicate: AXPStandardSectionItemsBuilderComponent, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"axm-asset-type-section-builder\">\n  @if (!readonly() && !hideHeaderActions() && allowAddSection()) {\n  <div class=\"__header\">\n    <div class=\"__header-left\"></div>\n    <div class=\"__header-right\">\n      <ax-button\n        class=\"ax-sm\"\n        [text]=\"'@asset-management:assetTypeSections.entities.assetTypeSection.actions.add-section.title' | translate | async\"\n        [color]=\"'primary'\"\n        (onClick)=\"addSection()\">\n        <ax-prefix>\n          <ax-icon icon=\"fa-light fa-layer-group\"></ax-icon>\n        </ax-prefix>\n      </ax-button>\n    </div>\n  </div>\n  }\n\n  <axp-standard-section-items-builder\n    class=\"block min-h-[200px]\"\n    [value]=\"builderValue()\"\n    [config]=\"standardConfig()\"\n    [readonly]=\"readonly()\"\n    (valueChange)=\"onBuilderValueChange($event)\" />\n</div>\n", styles: [".axm-asset-type-section-builder .__header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;align-items:center;justify-content:space-between}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2.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: AXTranslationModule }, { kind: "component", type: AXPStandardSectionItemsBuilderComponent, selector: "axp-standard-section-items-builder", inputs: ["value", "config", "readonly"], outputs: ["valueChange"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeSectionBuilderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-asset-type-section-builder', changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                        CommonModule,
+                        AXButtonModule,
+                        AXDecoratorModule,
+                        AXTranslationModule,
+                        AXPStandardSectionItemsBuilderComponent,
+                    ], template: "<div class=\"axm-asset-type-section-builder\">\n  @if (!readonly() && !hideHeaderActions() && allowAddSection()) {\n  <div class=\"__header\">\n    <div class=\"__header-left\"></div>\n    <div class=\"__header-right\">\n      <ax-button\n        class=\"ax-sm\"\n        [text]=\"'@asset-management:assetTypeSections.entities.assetTypeSection.actions.add-section.title' | translate | async\"\n        [color]=\"'primary'\"\n        (onClick)=\"addSection()\">\n        <ax-prefix>\n          <ax-icon icon=\"fa-light fa-layer-group\"></ax-icon>\n        </ax-prefix>\n      </ax-button>\n    </div>\n  </div>\n  }\n\n  <axp-standard-section-items-builder\n    class=\"block min-h-[200px]\"\n    [value]=\"builderValue()\"\n    [config]=\"standardConfig()\"\n    [readonly]=\"readonly()\"\n    (valueChange)=\"onBuilderValueChange($event)\" />\n</div>\n", styles: [".axm-asset-type-section-builder .__header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;align-items:center;justify-content:space-between}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], assetTypeId: [{ type: i0.Input, args: [{ isSignal: true, alias: "assetTypeId", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }], standardRef: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPStandardSectionItemsBuilderComponent), { isSignal: true }] }] } });
+
+const ASSET_TYPE_COMPONENTS_SAVE_COMMAND = 'AssetType:Components:Save';
+class AXMSaveAssetTypeComponentsCommand {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(input) {
+        const id = input?.id;
+        const entityRef = input?.entity || `${RootConfig.module.name}.${RootConfig.entities.assetType.name}`;
+        const field = input?.field || 'components';
+        const value = input?.value ?? { sections: [] };
+        if (!id) {
+            return {
+                success: false,
+                message: {
+                    text: await this.translationService.translateAsync('@general:messages.entity.invalid-data'),
+                },
+            };
+        }
+        try {
+            const payload = { [field]: value };
+            const isAssetTypeComponentsUpdate = entityRef === `${RootConfig.module.name}.${RootConfig.entities.assetType.name}` && field === 'components';
+            if (isAssetTypeComponentsUpdate) {
+                payload['name'] = this.ensureLatinName(input.name, {
+                    fallback: input.title,
+                    id,
+                });
+            }
+            await this.entityService.withEntity(entityRef).data().update(id, payload);
+            return { success: true, kind: 'object',
+                data: { id, field, value },
+                message: {
+                    text: await this.translationService.translateAsync('@general:messages.generic.success.description'),
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : await this.translationService.translateAsync('@general:messages.generic.error.description');
+            return {
+                success: false,
+                message: {
+                    text: message,
+                },
+            };
+        }
+    }
+    ensureLatinName(raw, context) {
+        const fromRaw = this.toLatinIdentifier(raw);
+        if (fromRaw) {
+            return fromRaw;
+        }
+        const fromTitle = this.toLatinIdentifier(context?.fallback);
+        if (fromTitle) {
+            return fromTitle;
+        }
+        const fromId = this.toLatinIdentifier(context?.id);
+        if (fromId) {
+            return fromId;
+        }
+        return 'asset_type';
+    }
+    toLatinIdentifier(value) {
+        if (typeof value !== 'string') {
+            return '';
+        }
+        return value
+            .replace(/[^A-Za-z0-9_-]+/g, '_')
+            .replace(/^_+|_+$/g, '')
+            .replace(/_{2,}/g, '_');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSaveAssetTypeComponentsCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSaveAssetTypeComponentsCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMSaveAssetTypeComponentsCommand, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var saveAssetTypeComponents_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ASSET_TYPE_COMPONENTS_SAVE_COMMAND: ASSET_TYPE_COMPONENTS_SAVE_COMMAND,
+    AXMSaveAssetTypeComponentsCommand: AXMSaveAssetTypeComponentsCommand
+});
+
+const ASSET_TYPE_SECTIONS_ADD_SECTION_COMMAND = 'AssetType:Sections:AddSection';
+const ASSET_TYPE_SECTIONS_DISCARD_COMMAND = 'AssetType:Sections:Discard';
+const ASSET_TYPE_SECTIONS_SAVE_COMMAND = 'AssetType:Sections:Save';
+class AXMAssetTypeSectionBuilderPageComponent extends AXPPageLayoutBaseComponent {
+    constructor() {
+        super(...arguments);
+        /** Default `{}`: required inputs throw (NG0950) if read before `AXPPageComponentRendererDirective` calls `setInput` after `createComponent`. */
+        this.rootContext = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rootContext" }] : /* istanbul ignore next */ []));
+        this.pageConfig = input(/* @ts-ignore */
+        ...(ngDevMode ? [undefined, { debugName: "pageConfig" }] : /* istanbul ignore next */ []));
+        this.options = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
+        this.builderRef = viewChild('builderRef', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderRef" }] : /* istanbul ignore next */ []));
+        this.commandService = inject(AXPCommandService);
+        this.entityService = inject(AXPEntityService);
+        this.hostPageLayout = inject(AXPPageLayoutBase, { optional: true, skipSelf: true });
+        this.baselineValue = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "baselineValue" }] : /* istanbul ignore next */ []));
+        this.committedValue = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "committedValue" }] : /* istanbul ignore next */ []));
+        this.config = computed(() => ({
+            ...(this.pageConfig() ?? {}),
+            ...(this.options() ?? {}),
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "config" }] : /* istanbul ignore next */ []));
+        this.fieldName = computed(() => {
+            const field = this.readStringConfig('field');
+            return field || 'components';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "fieldName" }] : /* istanbul ignore next */ []));
+        this.sourceFieldName = computed(() => {
+            const field = this.readStringConfig('sourceField');
+            return field || this.fieldName();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sourceFieldName" }] : /* istanbul ignore next */ []));
+        this.sourceIdPath = computed(() => {
+            const path = this.readStringConfig('sourceIdPath');
+            return path || 'id';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sourceIdPath" }] : /* istanbul ignore next */ []));
+        this.targetIdPath = computed(() => {
+            const path = this.readStringConfig('targetIdPath');
+            return path || this.sourceIdPath();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "targetIdPath" }] : /* istanbul ignore next */ []));
+        this.sourceEntityRef = computed(() => {
+            const entity = this.readStringConfig('sourceEntity');
+            return entity || `${RootConfig.module.name}.${RootConfig.entities.assetType.name}`;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sourceEntityRef" }] : /* istanbul ignore next */ []));
+        this.targetEntityRef = computed(() => {
+            const entity = this.readStringConfig('targetEntity');
+            return entity || this.sourceEntityRef();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "targetEntityRef" }] : /* istanbul ignore next */ []));
+        this.context = computed(() => this.rootContext(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
+        this.sourceRecordId = computed(() => {
+            const id = get(this.context(), this.sourceIdPath());
+            return typeof id === 'string' ? id : undefined;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sourceRecordId" }] : /* istanbul ignore next */ []));
+        this.targetRecordId = computed(() => {
+            const id = get(this.context(), this.targetIdPath());
+            return typeof id === 'string' ? id : undefined;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "targetRecordId" }] : /* istanbul ignore next */ []));
+        this.readonly = computed(() => this.readBooleanConfig('readonly'), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        this.linkAssetMode = computed(() => this.readBooleanConfig('linkAssetMode'), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "linkAssetMode" }] : /* istanbul ignore next */ []));
+        this.allowAddSection = computed(() => this.readBooleanConfig('allowAddSection', true), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddSection" }] : /* istanbul ignore next */ []));
+        this.allowAddItems = computed(() => this.readBooleanConfig('allowAddItems', true), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowAddItems" }] : /* istanbul ignore next */ []));
+        this.allowEditSection = computed(() => this.readBooleanConfig('allowEditSection', true), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowEditSection" }] : /* istanbul ignore next */ []));
+        this.allowReorderSections = computed(() => this.readBooleanConfig('allowReorderSections', true), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowReorderSections" }] : /* istanbul ignore next */ []));
+        this.builderOptions = computed(() => ({
+            hideHeaderActions: true,
+            readonly: this.readonly(),
+            linkAssetMode: this.linkAssetMode(),
+            mainAssetId: this.targetRecordId(),
+            allowAddSection: this.allowAddSection(),
+            allowEditSection: this.allowEditSection(),
+            allowAddItems: this.allowAddItems(),
+            allowReorderSections: this.allowReorderSections(),
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "builderOptions" }] : /* istanbul ignore next */ []));
+        this.isDirty = computed(() => {
+            const baseline = this.baselineValue();
+            const committed = this.committedValue();
+            return !isEqual(baseline ?? null, committed ?? null);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isDirty" }] : /* istanbul ignore next */ []));
+        this.#syncFromContext = effect((onCleanup) => {
+            const ctx = this.context();
+            const id = this.sourceRecordId();
+            const value = get(ctx, this.fieldName());
+            const linkedFromContext = get(ctx, this.fieldName());
+            const sourceValue = get(ctx, this.sourceFieldName());
+            const sourceField = this.sourceFieldName();
+            const immediateValue = this.linkAssetMode()
+                ? this.buildLinkedAssetValue(sourceValue ?? null, this.pickPersistedComponentLinks(linkedFromContext, undefined))
+                : (value ?? null);
+            this.baselineValue.set(immediateValue);
+            this.committedValue.set(immediateValue);
+            untracked(() => this.recompute());
+            if (!id) {
+                return;
+            }
+            let cancelled = false;
+            const sourceEntityRef = this.sourceEntityRef();
+            const targetEntityRef = this.targetEntityRef();
+            const targetRecordId = this.targetRecordId();
+            const linkMode = this.linkAssetMode();
+            const fieldName = this.fieldName();
+            const shouldFetchPersistedLinksFromTarget = linkMode &&
+                typeof targetRecordId === 'string' &&
+                targetRecordId.length > 0 &&
+                targetEntityRef !== sourceEntityRef;
+            const load = async () => {
+                try {
+                    const [sourceRecord, targetRecord] = await Promise.all([
+                        this.entityService.withEntity(sourceEntityRef).data().byKey(id),
+                        shouldFetchPersistedLinksFromTarget
+                            ? this.entityService.withEntity(targetEntityRef).data().byKey(targetRecordId)
+                            : Promise.resolve(null),
+                    ]);
+                    if (cancelled)
+                        return;
+                    const fallbackValue = get(sourceRecord, sourceField);
+                    const recordLinksUnknown = linkMode && shouldFetchPersistedLinksFromTarget
+                        ? get(targetRecord, fieldName)
+                        : linkMode
+                            ? get(sourceRecord, fieldName)
+                            : undefined;
+                    const resolved = linkMode
+                        ? this.buildLinkedAssetValue(sourceValue ?? fallbackValue ?? null, this.pickPersistedComponentLinks(linkedFromContext, recordLinksUnknown))
+                        : this.hasSections(value)
+                            ? value
+                            : (fallbackValue ?? null);
+                    this.baselineValue.set(resolved);
+                    this.committedValue.set(resolved);
+                    untracked(() => this.recompute());
+                }
+                catch {
+                    if (cancelled)
+                        return;
+                    this.baselineValue.set(immediateValue);
+                    this.committedValue.set(immediateValue);
+                    untracked(() => this.recompute());
+                }
+            };
+            void load();
+            onCleanup(() => {
+                cancelled = true;
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncFromContext" }] : /* istanbul ignore next */ []));
+    }
+    #syncFromContext;
+    onValueChange(value) {
+        this.committedValue.set(value);
+        this.updateRootContextField(this.fieldName(), this.linkAssetMode() ? this.toAssetComponentValue(value) : value);
+        this.recompute();
+    }
+    getWizardStepContext() {
+        const field = this.fieldName();
+        const value = this.committedValue();
+        if (!field || value == null) {
+            return null;
+        }
+        const ctxValue = this.linkAssetMode() ? this.toAssetComponentValue(value) : value;
+        return { [field]: cloneDeep(ctxValue) };
+    }
+    hasUnsavedChanges() {
+        return this.isDirty();
+    }
+    async getPrimaryMenuItems() {
+        if (this.readonly()) {
+            return [];
+        }
+        const addSectionTitle = (await this.translateService.translateAsync('@asset-management:assetTypeSections.entities.assetTypeSection.actions.add-section.title')) || 'Add Section';
+        const discardTitle = (await this.translateService.translateAsync('@general:actions.discard.title')) || 'Discard';
+        const saveTitle = (await this.translateService.translateAsync('@general:actions.save.title')) || 'Save';
+        return [
+            ...(this.allowAddSection()
+                ? [
+                    {
+                        title: addSectionTitle,
+                        icon: 'fa-light fa-layer-group',
+                        zone: 'header',
+                        priority: 'primary',
+                        color: 'primary',
+                        command: { name: ASSET_TYPE_SECTIONS_ADD_SECTION_COMMAND, options: {} },
+                    },
+                ]
+                : []),
+            {
+                title: discardTitle,
+                icon: 'fa-light fa-rotate-left',
+                zone: 'footer',
+                priority: 'secondary',
+                color: 'default',
+                visible: this.isDirty(),
+                command: { name: ASSET_TYPE_SECTIONS_DISCARD_COMMAND, options: {} },
+            },
+            {
+                title: saveTitle,
+                icon: 'fa-light fa-floppy-disk',
+                zone: 'footer',
+                priority: 'primary',
+                color: 'primary',
+                visible: this.isDirty(),
+                command: { name: ASSET_TYPE_SECTIONS_SAVE_COMMAND, options: {} },
+            },
+        ];
+    }
+    async execute(command) {
+        if (command.name === ASSET_TYPE_SECTIONS_ADD_SECTION_COMMAND) {
+            await this.builderRef()?.addSection();
+            return;
+        }
+        if (command.name === ASSET_TYPE_SECTIONS_DISCARD_COMMAND) {
+            this.handleDiscard();
+            return;
+        }
+        if (command.name !== ASSET_TYPE_SECTIONS_SAVE_COMMAND)
+            return;
+        await this.handleSave({ silent: false });
+    }
+    async handleSave(options) {
+        const silent = options?.silent === true;
+        const id = this.targetRecordId();
+        const entity = this.targetEntityRef();
+        const field = this.fieldName();
+        const value = this.committedValue();
+        if (!id || !entity || !field) {
+            if (!silent) {
+                this.toastService.show({
+                    color: 'danger',
+                    title: await this.translateService.translateAsync('@general:messages.error.title'),
+                    content: await this.translateService.translateAsync('@general:messages.entity.invalid-data'),
+                });
+            }
+            return;
+        }
+        const root = (this.rootContext() ?? {});
+        const result = await this.commandService.execute(ASSET_TYPE_COMPONENTS_SAVE_COMMAND, {
+            id,
+            entity,
+            field,
+            value: this.linkAssetMode() ? this.toAssetComponentValue(value ?? { sections: [] }) : (value ?? { sections: [] }),
+            name: root['name'],
+            title: root['title'],
+        });
+        if (result?.success) {
+            const saved = value ?? { sections: [] };
+            this.baselineValue.set(saved);
+            this.committedValue.set(saved);
+            this.updateRootContextField(field, this.linkAssetMode() ? this.toAssetComponentValue(saved) : saved);
+            this.builderRef()?.syncAfterSave(saved);
+            this.recompute();
+            if (!silent) {
+                this.toastService.show({
+                    color: 'success',
+                    title: await this.translateService.translateAsync('@general:messages.generic.success.title'),
+                    content: await this.translateService.translateAsync('@general:messages.generic.success.description'),
+                });
+            }
+            return;
+        }
+        this.toastService.show({
+            color: 'danger',
+            title: await this.translateService.translateAsync('@general:messages.error.title'),
+            content: await this.translateService.translateAsync('@general:messages.entity.update-failed'),
+        });
+    }
+    recompute() {
+        super.recompute();
+        const layout = this.hostPageLayout;
+        layout?.recompute?.();
+    }
+    handleDiscard() {
+        const baseline = this.baselineValue() ?? { sections: [] };
+        const field = this.fieldName();
+        this.committedValue.set(baseline);
+        this.updateRootContextField(field, this.linkAssetMode() ? this.toAssetComponentValue(baseline) : baseline);
+        this.builderRef()?.resetAfterDiscard();
+        this.recompute();
+    }
+    /** Keeps details-view `rootContext` in sync so sidebar navigation remounts with latest data. */
+    updateRootContextField(field, value) {
+        const ctx = this.rootContext();
+        if (!ctx || typeof ctx !== 'object') {
+            return;
+        }
+        ctx[field] = cloneDeep(value);
+    }
+    buildLinkedAssetValue(source, links) {
+        if (!source || !Array.isArray(source.sections)) {
+            return { sections: [] };
+        }
+        const groupedLinks = new Map();
+        for (const link of links ?? []) {
+            const key = String(link.assetTypeSectionComponentId ?? '');
+            if (!key)
+                continue;
+            if (!groupedLinks.has(key))
+                groupedLinks.set(key, []);
+            groupedLinks.get(key).push(link);
+        }
+        return {
+            sections: source.sections.map((section) => ({
+                ...section,
+                items: (section.items ?? []).flatMap((item) => {
+                    const componentId = String(item.id ?? '');
+                    const count = Math.max(1, Number(item.count ?? 1));
+                    const existing = groupedLinks.get(componentId) ?? [];
+                    return Array.from({ length: count }).map((_, index) => {
+                        const linked = existing[index];
+                        return {
+                            ...item,
+                            id: `${componentId}__slot_${index + 1}`,
+                            count: 1,
+                            assetTypeSectionComponentId: componentId,
+                            roleName: this.withSlotSuffix(item.roleName, index + 1),
+                            assetId: linked?.assetId,
+                            asset: linked?.asset
+                                ? {
+                                    id: linked.asset.id,
+                                    code: linked.asset.code,
+                                    title: linked.asset.title,
+                                }
+                                : undefined,
+                        };
+                    });
+                }),
+            })),
+        };
+    }
+    withSlotSuffix(value, slotIndex) {
+        const normalized = normalizeAssetTypeBuilderLocalizedField(value, '');
+        const suffix = `#${slotIndex}`;
+        if (typeof normalized === 'string') {
+            const base = normalized.trim();
+            return base ? `${base} ${suffix}` : suffix;
+        }
+        return Object.fromEntries(Object.entries(normalized).map(([locale, text]) => {
+            const trimmed = typeof text === 'string' ? text.trim() : '';
+            return [locale, trimmed ? `${trimmed} ${suffix}` : suffix];
+        }));
+    }
+    toAssetComponentValue(value) {
+        const mainAssetId = this.targetRecordId() ?? '';
+        return value.sections.flatMap((section) => (section.items ?? [])
+            .filter((item) => typeof item.assetId === 'string' && item.assetId)
+            .map((item) => ({
+            id: item.id,
+            assetId: String(item.assetId),
+            asset: {
+                id: String(item.asset?.id ?? item.assetId),
+                code: String(item.asset?.code ?? ''),
+                title: String(item.asset?.title ?? ''),
+            },
+            mainAssetId,
+            mainAsset: {
+                id: mainAssetId,
+                code: '',
+                title: '',
+            },
+            assetTypeSectionComponentId: String(item.assetTypeSectionComponentId ?? ''),
+            assetTypeSectionComponent: {
+                id: String(item.assetTypeSectionComponentId ?? ''),
+                code: String(item.assetTypeSectionId ?? ''),
+                title: String(item.roleName ?? ''),
+                assetTypeId: String(item.assetTypeId ?? ''),
+                assetType: {
+                    id: String(item.assetType?.id ?? String(item.assetTypeId ?? '')),
+                    name: item.assetType?.name ?? '',
+                },
+            },
+        })));
+    }
+    readStringConfig(key) {
+        const rootValue = this.config()[key];
+        if (typeof rootValue === 'string') {
+            return rootValue;
+        }
+        return '';
+    }
+    readBooleanConfig(key, defaultValue = false) {
+        const rootValue = this.config()[key];
+        if (typeof rootValue === 'boolean') {
+            return rootValue;
+        }
+        return defaultValue;
+    }
+    hasSections(value) {
+        return !!value && Array.isArray(value.sections) && value.sections.length > 0;
+    }
+    /**
+     * Prefer links loaded with the record (`byKey`). Context often holds `assetComponents: []` from a
+     * partial row merge; `[] ?? serverLinks` would keep the empty array and hide persisted assignments.
+     */
+    pickPersistedComponentLinks(contextLinks, recordLinks) {
+        if (recordLinks !== undefined) {
+            return Array.isArray(recordLinks) ? recordLinks : [];
+        }
+        return Array.isArray(contextLinks) ? contextLinks : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeSectionBuilderPageComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "22.0.8", type: AXMAssetTypeSectionBuilderPageComponent, isStandalone: true, selector: "axm-asset-type-section-builder-page", inputs: { rootContext: { classPropertyName: "rootContext", publicName: "rootContext", isSignal: true, isRequired: false, transformFunction: null }, pageConfig: { classPropertyName: "pageConfig", publicName: "pageConfig", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.axp-page-layout-base": "true" } }, providers: [
+            {
+                provide: AXPPageLayoutBase,
+                useExisting: AXMAssetTypeSectionBuilderPageComponent,
+            },
+        ], viewQueries: [{ propertyName: "builderRef", first: true, predicate: ["builderRef"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    <axm-asset-type-section-builder
+      #builderRef
+      [value]="committedValue()"
+      [assetTypeId]="sourceRecordId()"
+      [options]="builderOptions()"
+      (valueChange)="onValueChange($event)"
+    />
+  `, isInline: true, dependencies: [{ kind: "component", type: AXMAssetTypeSectionBuilderComponent, selector: "axm-asset-type-section-builder", inputs: ["value", "assetTypeId", "options"], outputs: ["valueChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeSectionBuilderPageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-asset-type-section-builder-page',
+                    standalone: true,
+                    imports: [AXMAssetTypeSectionBuilderComponent],
+                    providers: [
+                        {
+                            provide: AXPPageLayoutBase,
+                            useExisting: AXMAssetTypeSectionBuilderPageComponent,
+                        },
+                    ],
+                    template: `
+    <axm-asset-type-section-builder
+      #builderRef
+      [value]="committedValue()"
+      [assetTypeId]="sourceRecordId()"
+      [options]="builderOptions()"
+      (valueChange)="onValueChange($event)"
+    />
+  `,
+                    host: {
+                        '[class.axp-page-layout-base]': 'true',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { rootContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "rootContext", required: false }] }], pageConfig: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageConfig", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], builderRef: [{ type: i0.ViewChild, args: ['builderRef', { isSignal: true }] }] } });
+
+var assetTypeSectionBuilderPage_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAssetTypeSectionBuilderPageComponent: AXMAssetTypeSectionBuilderPageComponent
+});
+
+class AXMAssetTypeComponentsPageComponentProvider {
+    async components() {
+        return [
+            {
+                key: ASSET_TYPE_COMPONENTS_PAGE_COMPONENT_KEY,
+                loader: () => Promise.resolve().then(function () { return assetTypeSectionBuilderPage_component; }).then((m) => m.AXMAssetTypeSectionBuilderPageComponent),
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeComponentsPageComponentProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeComponentsPageComponentProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetTypeComponentsPageComponentProvider, decorators: [{
+            type: Injectable
+        }] });
+
+var index = /*#__PURE__*/_mergeNamespaces({
+    __proto__: null,
+    ASSET_TYPE_COMPONENTS_SAVE_COMMAND: ASSET_TYPE_COMPONENTS_SAVE_COMMAND,
+    AXMAssetTypeComponentsPageComponentProvider: AXMAssetTypeComponentsPageComponentProvider,
+    AXMAssetTypeSectionBuilderComponent: AXMAssetTypeSectionBuilderComponent,
+    AXMAssetTypeSectionBuilderPageComponent: AXMAssetTypeSectionBuilderPageComponent,
+    AXMSaveAssetTypeComponentsCommand: AXMSaveAssetTypeComponentsCommand,
+    createAssetTypeSectionBuilderDefaultValue: createAssetTypeSectionBuilderDefaultValue,
+    normalizeAssetTypeBuilderLocalizedField: normalizeAssetTypeBuilderLocalizedField,
+    normalizeAssetTypeSectionBuilderValue: normalizeAssetTypeSectionBuilderValue
+}, [contracts]);
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+const BLOCKING_WORK_ORDER_STATUSES = new Set(['in-progress', 'completed']);
+const PROTECTED_LIFECYCLE_STATUSES = new Set([AXMAssetLifecycleStatus.Retired, AXMAssetLifecycleStatus.Disposed]);
+const PROTECTED_OPERATIONAL_STATUSES = new Set([AXMAssetStatus.Lost]);
+//#endregion
+/**
+ * Central policy for asset operational status changes driven by maintenance work orders.
+ * Callers must not set `Asset.statusId` directly from workflows — use {@link recalculate} only.
+ */
+class AXMAssetOperationalStatusService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async recalculate(assetIdRaw, trigger, context = {}) {
+        const assetId = assetIdRaw?.trim();
+        if (!assetId) {
+            return {
+                assetId: '',
+                previousStatusId: null,
+                statusId: null,
+                changed: false,
+                reason: 'assetId is required',
+            };
+        }
+        const asset = (await this.entityService.withEntity('AssetManagement', 'Asset').data().byKey(assetId));
+        if (!asset?.id) {
+            return {
+                assetId,
+                previousStatusId: null,
+                statusId: null,
+                changed: false,
+                reason: 'Asset not found',
+            };
+        }
+        const previousStatusId = isString(asset.statusId) ? asset.statusId.trim() : null;
+        const lifecycleStatusId = isString(asset.lifecycleStatusId) ? asset.lifecycleStatusId.trim() : null;
+        if (lifecycleStatusId && PROTECTED_LIFECYCLE_STATUSES.has(lifecycleStatusId)) {
+            return {
+                assetId,
+                previousStatusId,
+                statusId: previousStatusId,
+                changed: false,
+                reason: `${trigger}: asset lifecycle is protected`,
+            };
+        }
+        if (previousStatusId && PROTECTED_OPERATIONAL_STATUSES.has(previousStatusId)) {
+            return {
+                assetId,
+                previousStatusId,
+                statusId: previousStatusId,
+                changed: false,
+                reason: `${trigger}: asset status is protected`,
+            };
+        }
+        const maintenanceTypeId = await this.resolveMaintenanceTypeId(assetId, context);
+        const shouldBlock = await this.shouldBlockAssetForMaintenance(assetId, maintenanceTypeId);
+        let nextStatusId = previousStatusId;
+        const update = {};
+        if (trigger === 'work-started') {
+            if (shouldBlock) {
+                nextStatusId = AXMAssetStatus.UnderMaintenanceInspection;
+                if (previousStatusId === AXMAssetStatus.Available || previousStatusId === AXMAssetStatus.Assigned) {
+                    update.statusBeforeInterruptionId = previousStatusId;
+                }
+            }
+        }
+        if (trigger === 'work-completed') {
+            const hasBlockingWork = await this.hasBlockingWorkOrders(assetId);
+            if (hasBlockingWork) {
+                nextStatusId = AXMAssetStatus.UnderMaintenanceInspection;
+            }
+            // Do not release the asset here — completed work still awaits sign-off.
+        }
+        if (trigger === 'work-signed-off') {
+            const hasBlockingWork = await this.hasBlockingWorkOrders(assetId);
+            if (hasBlockingWork) {
+                nextStatusId = AXMAssetStatus.UnderMaintenanceInspection;
+            }
+            else {
+                nextStatusId = this.resolveRestoredStatus(asset);
+                update.statusBeforeInterruptionId = null;
+            }
+        }
+        const changed = !!nextStatusId && nextStatusId !== previousStatusId;
+        const hasFieldUpdates = update.statusBeforeInterruptionId !== undefined;
+        if ((changed && nextStatusId) || hasFieldUpdates) {
+            await this.entityService
+                .withEntity('AssetManagement', 'Asset')
+                .data()
+                .update(assetId, {
+                ...update,
+                ...(changed && nextStatusId ? { statusId: nextStatusId } : {}),
+            });
+        }
+        return {
+            assetId,
+            previousStatusId,
+            statusId: nextStatusId,
+            changed,
+            reason: changed ? `${trigger}: status recalculated` : `${trigger}: status unchanged`,
+        };
+    }
+    //#endregion
+    //#region ---- Policy helpers ----
+    async resolveMaintenanceTypeId(assetId, context) {
+        const fromContext = context.maintenanceTypeId?.trim();
+        if (fromContext) {
+            return fromContext;
+        }
+        const workOrderId = context.workOrderId?.trim();
+        if (workOrderId) {
+            const workOrder = (await this.entityService
+                .withEntity('MaintenanceManagement', 'WorkOrder')
+                .data()
+                .byKey(workOrderId));
+            const fromWorkOrder = workOrder?.maintenanceTypeId?.trim();
+            if (fromWorkOrder) {
+                return fromWorkOrder;
+            }
+        }
+        const page = await this.entityService
+            .withEntity('MaintenanceManagement', 'WorkOrder')
+            .data()
+            .query({
+            skip: 0,
+            take: 1,
+            filter: {
+                logic: 'and',
+                filters: [
+                    { field: 'assetId', operator: { type: 'equal' }, value: assetId },
+                    { field: 'statusId', operator: { type: 'equal' }, value: 'in-progress' },
+                ],
+            },
+        });
+        const row = defaultTo(get(page, 'items[0]'), null);
+        return row?.maintenanceTypeId?.trim() ?? '';
+    }
+    /**
+     * Inspection-like maintenance types keep the asset blocked under the combined operational status.
+     * TODO: replace title/code heuristic with an explicit MaintenanceType classification field when available.
+     */
+    async shouldBlockAssetForMaintenance(_assetId, maintenanceTypeId) {
+        if (!maintenanceTypeId) {
+            return true;
+        }
+        const maintenanceType = (await this.entityService
+            .withEntity('MaintenanceManagement', 'MaintenanceType')
+            .data()
+            .byKey(maintenanceTypeId));
+        if (!maintenanceType) {
+            return true;
+        }
+        const code = maintenanceType.code?.toLowerCase() ?? '';
+        const titleText = this.resolveDisplayText(maintenanceType.title).toLowerCase();
+        const isInspection = code.includes('inspect') || titleText.includes('inspect');
+        if (isInspection) {
+            return true;
+        }
+        // Non-inspection maintenance that does not block the asset is not modeled yet.
+        // TODO: honor MaintenanceType.blocksAsset (or equivalent) when introduced.
+        return true;
+    }
+    async hasBlockingWorkOrders(assetId) {
+        const page = await this.entityService
+            .withEntity('MaintenanceManagement', 'WorkOrder')
+            .data()
+            .query({
+            skip: 0,
+            take: 100,
+            filter: {
+                logic: 'and',
+                filters: [{ field: 'assetId', operator: { type: 'equal' }, value: assetId }],
+            },
+        });
+        const items = defaultTo(get(page, 'items'), []);
+        return items.some((row) => {
+            const statusId = row.statusId?.trim();
+            return !!statusId && BLOCKING_WORK_ORDER_STATUSES.has(statusId);
+        });
+    }
+    resolveRestoredStatus(asset) {
+        const saved = isString(asset.statusBeforeInterruptionId) ? asset.statusBeforeInterruptionId.trim() : null;
+        if (saved) {
+            return saved;
+        }
+        return AXMAssetStatus.Available;
+    }
+    resolveDisplayText(value) {
+        if (isString(value)) {
+            return value;
+        }
+        if (value && typeof value === 'object') {
+            const record = value;
+            return record['en-US'] ?? record['fa-IR'] ?? Object.values(record)[0] ?? '';
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetOperationalStatusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetOperationalStatusService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetOperationalStatusService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Types ----
+//#endregion
+
+// export * from './asset-status.provider';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ASSET_TYPE_COMPONENTS_SAVE_COMMAND, AXMAssetManagementAssetStatusProvider, AXMAssetManagementFeatureDefinitionProvider, AXMAssetManagementMenuProvider, AXMAssetManagementModule, AXMAssetManagementPermissionDefinitionProvider, AXMAssetManagementSearchCommandProvider, AXMAssetOperationalStatusService, AXMAssetTypeComponentsPageComponentProvider, AXMAssetTypeSectionBuilderComponent, AXMAssetTypeSectionBuilderPageComponent, AXMCreateAssetRentalHistoryRentFromCommand, AXMCreateAssetRentalHistoryRentToCommand, AXMSaveAssetTypeComponentsCommand, assertRentalPartyForDirection, createAssetTypeSectionBuilderDefaultValue, normalizeAssetTypeBuilderLocalizedField, normalizeAssetTypeSectionBuilderValue };
+//# sourceMappingURL=acorex-platform-module-asset-management-client.mjs.map