@acorex-platform/module-asset-management-client 0.0.56 → 0.0.58

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

@@ -0,0 +1,2789 @@
+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_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 { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
+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, AXMAssetIntervalKind, AXMAssetIntervalUnit, resolveSupportedIntervalKinds, isAXMAssetUsageKind, AXM_ASSET_USAGE_VALUES_WIDGET, RootConfig, readAssetUsageValues, resolveAssetUsageWrite, AXM_ASSET_USAGE_WRITE_ERRORS, 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';
+import { AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+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 ----- Constants -----
+const AXM_ASSET_USAGE_I18N = '@asset-management:assets.entities.asset.fields.usage-values';
+const CONTEXT_PATHS = ['assetType.supportedIntervalKinds'];
+const USAGE_METER_KIND_ORDER = [
+    AXMAssetIntervalKind.Distance,
+    AXMAssetIntervalKind.OperatingHours,
+    AXMAssetIntervalKind.OperationCount,
+];
+const USAGE_KIND_LABEL_KEYS = {
+    [AXMAssetIntervalKind.Date]: `${AXM_ASSET_USAGE_I18N}.kinds.date`,
+    [AXMAssetIntervalKind.Distance]: `${AXM_ASSET_USAGE_I18N}.kinds.distance`,
+    [AXMAssetIntervalKind.OperatingHours]: `${AXM_ASSET_USAGE_I18N}.kinds.operating-hours`,
+    [AXMAssetIntervalKind.OperationCount]: `${AXM_ASSET_USAGE_I18N}.kinds.operation-count`,
+};
+const USAGE_UNIT_LABEL_KEYS = {
+    [AXMAssetIntervalUnit.Kilometer]: `${AXM_ASSET_USAGE_I18N}.units.kilometer`,
+    [AXMAssetIntervalUnit.Mile]: `${AXM_ASSET_USAGE_I18N}.units.mile`,
+    [AXMAssetIntervalUnit.Hour]: `${AXM_ASSET_USAGE_I18N}.units.hour`,
+    [AXMAssetIntervalUnit.Operation]: `${AXM_ASSET_USAGE_I18N}.units.operation`,
+};
+//#endregion
+//#region ----- Supported kinds -----
+/** Widget option first, then the asset type already on the form. */
+function readAssetUsageIntervalKinds(options, readContext) {
+    const record = options;
+    if ('supportedIntervalKinds' in record) {
+        return resolveSupportedIntervalKinds(record['supportedIntervalKinds']).kinds;
+    }
+    for (const path of CONTEXT_PATHS) {
+        const resolved = resolveSupportedIntervalKinds(readContext(path));
+        if (resolved.kinds.length > 0) {
+            return resolved.kinds;
+        }
+    }
+    return [];
+}
+function orderedUsageMeterKinds(kinds) {
+    return USAGE_METER_KIND_ORDER.filter((kind) => kinds.includes(kind));
+}
+function isUsageMeterKind(value) {
+    return isAXMAssetUsageKind(value);
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Widget config -----
+const AXMAssetUsageValuesWidget = {
+    name: AXM_ASSET_USAGE_VALUES_WIDGET,
+    title: `${AXM_ASSET_USAGE_I18N}.title`,
+    description: `${AXM_ASSET_USAGE_I18N}.description`,
+    type: 'editor',
+    designer: { needLabel: true },
+    categories: [],
+    groups: [AXPWidgetGroupEnum.EntityWidget],
+    icon: 'fa-light fa-gauge',
+    properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY],
+    components: {
+        view: {
+            component: () => import('./acorex-platform-module-asset-management-client-asset-usage-values-widget-view.component-5psJebph.mjs').then((c) => c.AXMAssetUsageValuesWidgetViewComponent),
+        },
+        edit: {
+            component: () => import('./acorex-platform-module-asset-management-client-asset-usage-values-widget-edit.component-qauvpIMv.mjs').then((c) => c.AXMAssetUsageValuesWidgetEditComponent),
+        },
+        designer: {
+            component: () => import('./acorex-platform-module-asset-management-client-asset-usage-values-widget-edit.component-qauvpIMv.mjs').then((c) => c.AXMAssetUsageValuesWidgetEditComponent),
+        },
+    },
+};
+//#endregion
+
+//#endregion
+//#region ----- Provider -----
+class AXMAssetUsageValuesWidgetProvider {
+    getWidgets() {
+        return [AXMAssetUsageValuesWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetUsageValuesWidgetProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetUsageValuesWidgetProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetUsageValuesWidgetProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#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 ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+const ASSET_TYPE_ENTITY$1 = `${RootConfig.module.name}.${RootConfig.entities.assetType.name}`;
+const INVALID_INTERVAL_KINDS_MESSAGE = '@asset-management:assetTypes.entities.assetType.fields.supported-interval-kinds.validation.invalid';
+//#endregion
+//#region ---- Helpers ----
+function applySupportedIntervalKinds(record, kinds) {
+    record['supportedIntervalKinds'] = kinds;
+}
+function readRecord$1(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+//#endregion
+//#region ---- Asset type interval kinds middleware ----
+/**
+ * Persists `supportedIntervalKinds` as a string array.
+ * Missing or empty input is saved and returned as `[]`. Unknown values abort the write.
+ */
+const assetTypeIntervalKindsMiddleware = {
+    target: {
+        ops: ['create', 'update', 'upsertOne', 'getOne', 'getAll', 'query', 'queryAll', 'getMany'],
+        entity: ASSET_TYPE_ENTITY$1,
+        order: 12,
+    },
+    execute: async (ctx, next) => {
+        const isWrite = ctx.op === 'create' || ctx.op === 'update' || ctx.op === 'upsertOne';
+        if (isWrite && ctx.data && typeof ctx.data === 'object') {
+            const data = ctx.data;
+            const fieldPresent = ctx.op === 'create' || ctx.op === 'upsertOne' || 'supportedIntervalKinds' in data;
+            if (fieldPresent) {
+                const resolved = resolveSupportedIntervalKinds(data['supportedIntervalKinds']);
+                if (resolved.invalid) {
+                    throw new AXPMiddlewareAbortError(INVALID_INTERVAL_KINDS_MESSAGE, {
+                        code: 'ASSET_TYPE_INTERVAL_KIND_INVALID',
+                        status: 400,
+                    });
+                }
+                applySupportedIntervalKinds(data, resolved.kinds);
+            }
+        }
+        await next();
+        if (ctx.op === 'getOne') {
+            const record = readRecord$1(ctx.result);
+            if (record) {
+                applySupportedIntervalKinds(record, resolveSupportedIntervalKinds(record['supportedIntervalKinds']).kinds);
+            }
+            return;
+        }
+        const items = Array.isArray(ctx.result)
+            ? ctx.result
+            : Array.isArray(ctx.result?.items)
+                ? ctx.result.items
+                : null;
+        if (!items) {
+            return;
+        }
+        for (const item of items) {
+            const record = readRecord$1(item);
+            if (!record) {
+                continue;
+            }
+            applySupportedIntervalKinds(record, resolveSupportedIntervalKinds(record['supportedIntervalKinds']).kinds);
+        }
+    },
+};
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+const ASSET_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.asset.name}`;
+const ASSET_TYPE_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.assetType.name}`;
+const WRITE_OPS = new Set(['create', 'update', 'upsertOne']);
+//#endregion
+//#region ---- Helpers ----
+function readRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function assignUsageValues(record) {
+    record['usageValues'] = readAssetUsageValues(record['usageValues']);
+}
+async function loadStoredAsset(ctx) {
+    const previous = readRecord(ctx.previous);
+    if (previous) {
+        return previous;
+    }
+    if (ctx.op === 'create' || ctx.id == null || ctx.id === '') {
+        return null;
+    }
+    if (ctx.op === 'upsertOne') {
+        try {
+            return readRecord(await ctx.backend.getOne(ASSET_ENTITY, ctx.id));
+        }
+        catch {
+            return null;
+        }
+    }
+    return readRecord(await ctx.backend.getOne(ASSET_ENTITY, ctx.id));
+}
+async function loadSupportedKinds(ctx, assetTypeId) {
+    if (typeof assetTypeId !== 'string' || assetTypeId.length === 0) {
+        return [];
+    }
+    const assetType = readRecord(await ctx.backend.getOne(ASSET_TYPE_ENTITY, assetTypeId));
+    return resolveSupportedIntervalKinds(assetType?.['supportedIntervalKinds']).kinds;
+}
+//#endregion
+//#region ---- Asset usage values middleware ----
+/**
+ * Stores one current reading per meter kind.
+ * A missing create value is `[]`. An update replaces the same kind and keeps the others.
+ */
+const assetUsageValuesMiddleware = {
+    target: {
+        ops: ['create', 'update', 'upsertOne', 'getOne', 'getAll', 'query', 'queryAll', 'getMany'],
+        entity: ASSET_ENTITY,
+        order: 14,
+    },
+    execute: async (ctx, next) => {
+        if (WRITE_OPS.has(ctx.op)) {
+            const data = readRecord(ctx.data);
+            const fieldPresent = ctx.op === 'create' || ctx.op === 'upsertOne' || (data != null && 'usageValues' in data);
+            if (data && fieldPresent) {
+                const stored = await loadStoredAsset(ctx);
+                const incoming = data['usageValues'];
+                const supportedKinds = Array.isArray(incoming) && incoming.length > 0
+                    ? await loadSupportedKinds(ctx, data['assetTypeId'] ?? stored?.['assetTypeId'])
+                    : [];
+                const resolved = resolveAssetUsageWrite(incoming, {
+                    supportedKinds,
+                    previous: stored?.['usageValues'],
+                    mergeWithPrevious: stored != null && ctx.op !== 'create',
+                });
+                if (resolved.issue) {
+                    const error = AXM_ASSET_USAGE_WRITE_ERRORS[resolved.issue];
+                    throw new AXPMiddlewareAbortError(error.message, { code: error.code, status: 400 });
+                }
+                data['usageValues'] = resolved.values;
+            }
+        }
+        await next();
+        if (WRITE_OPS.has(ctx.op)) {
+            return;
+        }
+        if (ctx.op === 'getOne') {
+            const record = readRecord(ctx.result);
+            if (record) {
+                assignUsageValues(record);
+            }
+            return;
+        }
+        const items = Array.isArray(ctx.result)
+            ? ctx.result
+            : Array.isArray(ctx.result?.items)
+                ? ctx.result.items
+                : null;
+        if (!items) {
+            return;
+        }
+        for (const item of items) {
+            const record = readRecord(item);
+            if (record) {
+                assignUsageValues(record);
+            }
+        }
+    },
+};
+//#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: [
+            {
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMAssetManagementCatalogScopeDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMAssetUsageValuesWidgetProvider,
+                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-RGXS9fI1.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,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: assetTypeIntervalKindsMiddleware,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: assetUsageValuesMiddleware,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMAssetManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMAssetManagementCatalogScopeDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMAssetUsageValuesWidgetProvider,
+                            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-RGXS9fI1.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,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: assetTypeIntervalKindsMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: assetUsageValuesMiddleware,
+                            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 raw = this.value();
+            // In link mode an empty value means "template not loaded yet" — do not invent a default section.
+            if (this.linkAssetMode() && (!raw || !Array.isArray(raw.sections) || raw.sections.length === 0)) {
+                this.builderValue.set({ sections: [] });
+                return;
+            }
+            const normalized = normalizeAssetTypeSectionBuilderValue(raw, 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 assetTypeId = this.resolveLinkedItemAssetTypeId(item);
+        const seed = {
+            assetId: String(item['assetId'] ?? ''),
+            assetTypeId,
+            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,
+        };
+    }
+    resolveLinkedItemAssetTypeId(item) {
+        const fromField = typeof item['assetTypeId'] === 'string' ? item['assetTypeId'].trim() : '';
+        if (fromField) {
+            return fromField;
+        }
+        const nested = item['assetType'];
+        if (nested && typeof nested.id === 'string' && nested.id.trim()) {
+            return nested.id.trim();
+        }
+        return '';
+    }
+    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(seed.assetTypeId));
+            })
+                .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 ?? seed.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(requiredAssetTypeId) {
+        const currentAssetId = this.options()['mainAssetId'];
+        const assetTypeFilterValue = typeof requiredAssetTypeId === 'string' && requiredAssetTypeId.trim()
+            ? requiredAssetTypeId.trim()
+            : "{{ context.eval('assetTypeId') }}";
+        const filters = [
+            ...(typeof currentAssetId === 'string' && currentAssetId
+                ? [{ field: 'id', operator: { type: 'notEqual' }, value: currentAssetId }]
+                : []),
+            {
+                field: 'assetTypeId',
+                operator: { type: 'equal' },
+                value: assetTypeFilterValue,
+            },
+        ];
+        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", "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 ctx = this.context();
+            const id = get(ctx, this.sourceIdPath());
+            if (typeof id === 'string' && id.length > 0) {
+                return id;
+            }
+            // Lookup expose often hydrates nested `assetType.id` before/without top-level assetTypeId.
+            if (this.sourceIdPath() === 'assetTypeId') {
+                const nested = get(ctx, 'assetType.id');
+                if (typeof nested === 'string' && nested.length > 0) {
+                    return nested;
+                }
+            }
+            return 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 linkMode = this.linkAssetMode();
+            const fieldName = this.fieldName();
+            const sourceField = this.sourceFieldName();
+            const value = get(ctx, fieldName);
+            const linkedFromContext = get(ctx, fieldName);
+            if (!linkMode) {
+                const immediateValue = (value ?? null);
+                this.baselineValue.set(immediateValue);
+                this.committedValue.set(immediateValue);
+                untracked(() => this.recompute());
+                if (!id) {
+                    return;
+                }
+                let cancelled = false;
+                const sourceEntityRef = this.sourceEntityRef();
+                const load = async () => {
+                    try {
+                        const sourceRecord = await this.entityService.withEntity(sourceEntityRef).data().byKey(id);
+                        if (cancelled)
+                            return;
+                        const fallbackValue = get(sourceRecord, sourceField);
+                        const resolved = 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;
+                });
+                return;
+            }
+            // ----- linkAssetMode: template from source entity (AssetType), links on target (Asset) -----
+            // Never use target context's `components` (or empty defaults) as the structure template.
+            if (!id) {
+                const empty = this.buildLinkedAssetValue(null, this.pickPersistedComponentLinks(linkedFromContext, undefined));
+                this.baselineValue.set(empty);
+                this.committedValue.set(empty);
+                untracked(() => this.recompute());
+                return;
+            }
+            let cancelled = false;
+            const sourceEntityRef = this.sourceEntityRef();
+            const targetEntityRef = this.targetEntityRef();
+            const targetRecordId = this.targetRecordId();
+            const shouldFetchPersistedLinksFromTarget = 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 template = get(sourceRecord, sourceField);
+                    const recordLinksUnknown = shouldFetchPersistedLinksFromTarget
+                        ? get(targetRecord, fieldName)
+                        : get(sourceRecord, fieldName);
+                    const resolved = this.buildLinkedAssetValue(this.hasSections(template) ? (template ?? null) : null, this.pickPersistedComponentLinks(linkedFromContext, recordLinksUnknown));
+                    this.baselineValue.set(resolved);
+                    this.committedValue.set(resolved);
+                    untracked(() => this.recompute());
+                }
+                catch {
+                    if (cancelled)
+                        return;
+                    // Keep whatever is already shown; do not wipe with an empty target-context template.
+                    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 { AXMAssetOperationalStatusService as A, USAGE_UNIT_LABEL_KEYS as U, AXM_ASSET_USAGE_I18N as a, USAGE_KIND_LABEL_KEYS as b, USAGE_METER_KIND_ORDER as c, ASSET_TYPE_COMPONENTS_SAVE_COMMAND as d, AXMAssetManagementAssetStatusProvider as e, AXMAssetManagementFeatureDefinitionProvider as f, AXMAssetManagementMenuProvider as g, AXMAssetManagementModule as h, isUsageMeterKind as i, AXMAssetManagementPermissionDefinitionProvider as j, AXMAssetManagementSearchCommandProvider as k, AXMAssetTypeComponentsPageComponentProvider as l, AXMAssetTypeSectionBuilderComponent as m, AXMAssetTypeSectionBuilderPageComponent as n, orderedUsageMeterKinds as o, AXMCreateAssetRentalHistoryRentFromCommand as p, AXMCreateAssetRentalHistoryRentToCommand as q, readAssetUsageIntervalKinds as r, AXMSaveAssetTypeComponentsCommand as s, assertRentalPartyForDirection as t, createAssetTypeSectionBuilderDefaultValue as u, normalizeAssetTypeBuilderLocalizedField as v, normalizeAssetTypeSectionBuilderValue as w };
+//# sourceMappingURL=acorex-platform-module-asset-management-client-acorex-platform-module-asset-management-client-B7YXKaeh.mjs.map