@acorex-platform/module-maintenance-management-client 0.0.21

package/fesm2022/acorex-platform-module-maintenance-management-client-acorex-platform-module-maintenance-management-client-BiQlJxPX.mjs

@@ -0,0 +1,2698 @@
+import { AXPSessionService, 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 { AXPDebugService, AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, provideLazyProvider } from '@acorex-platform/framework-client/core';
+import { AXPEntityStorageService, AXPEntityDefinitionRegistryService, AXPEntityDataSelectorService, AXPEntityService, AXP_ENTITY_STORAGE_MIDDLEWARE } from '@acorex-platform/framework-client/layout/entity';
+import { AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPCommandService, provideCommandMiddleware, provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule } from '@angular/core';
+import { RootConfig, AXMWorkOrderSourceType, AXMWorkOrderStatus, AXMMaintenanceManagementCommandKeys, MM_CATALOG_SCOPE_MN, AXPAssetsMaintenancePermissionKeys, AXMMaintenanceManagementMenuKeys } from '@acorex-platform/module-maintenance-management-client/contracts';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXToastService } from '@acorex/components/toast';
+import { isValidMultiLanguageObject, resolveMultiLanguageString, AXTranslationService, createMultiLanguageString } from '@acorex/core/translation';
+import { AXP_IDENTIFIER_SERVICE } from '@acorex-platform/module-identifier-management-client';
+import { isString, get, isNumber, defaultTo, isObject, isEmpty, isNil } from 'lodash';
+import { AXPEntityCommandScope } from '@acorex-platform/framework-shared/entity';
+import { AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXMAssetManagementCommandKeys } from '@acorex-platform/module-asset-management-client/contracts';
+
+//#region ---- Workflow debug namespace ----
+const AXM_WORK_ORDER_WORKFLOW_DEBUG_NAMESPACE = 'maintenance-management';
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Maintenance Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const MaintenanceManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'domain',
+    domain: 'asset-maintenance',
+    required: false,
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Identifier rules   ----
+const MAINTENANCE_PLAN_CODE_RULE_ID = 'maintenance-plan-code';
+const WORK_ORDER_NO_RULE_ID = 'work-order-no';
+//#endregion
+//#region ----   Helpers   ----
+const MAX_BY_DATE_OCCURRENCES = 10_000;
+function isTruthyFlag(value) {
+    return [true, 'true', 1, '1'].includes(value);
+}
+function isMultiLanguageString(value) {
+    return isValidMultiLanguageObject(value);
+}
+/**
+ * Normalizes plain or multilingual labels into a bilingual {@link AXPMultiLanguageString}.
+ */
+function normalizeMultiLanguageString(value, fallback) {
+    if (!value) {
+        return { 'en-US': fallback, 'fa-IR': fallback };
+    }
+    if (isString(value)) {
+        return { 'en-US': value, 'fa-IR': value };
+    }
+    if (isMultiLanguageString(value)) {
+        const en = resolveMultiLanguageString(value, 'en-US') || fallback;
+        const fa = resolveMultiLanguageString(value, 'fa-IR') || en;
+        return { 'en-US': en, 'fa-IR': fa };
+    }
+    return { 'en-US': fallback, 'fa-IR': fallback };
+}
+/**
+ * Resolves a display label for dialogs and messages (defaults to en-US).
+ */
+function resolveDisplayLabel(value, fallback, locale = 'en-US') {
+    if (!value) {
+        return fallback;
+    }
+    if (isString(value)) {
+        return value;
+    }
+    return resolveMultiLanguageString(value, locale) || fallback;
+}
+function combineMultiLanguageTitle(left, leftFallback, right, rightFallback) {
+    const leftMl = normalizeMultiLanguageString(left, leftFallback);
+    const rightMl = normalizeMultiLanguageString(right, rightFallback);
+    return {
+        'en-US': `${leftMl['en-US']} - ${rightMl['en-US']}`,
+        'fa-IR': `${leftMl['fa-IR']} - ${rightMl['fa-IR']}`,
+    };
+}
+function toDate(value) {
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : new Date(value.getTime());
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+    }
+    return undefined;
+}
+/** Treat schedule end dates as inclusive through the end of the calendar day. */
+function toScheduleEndBoundary(value) {
+    const date = toDate(value);
+    if (!date) {
+        return undefined;
+    }
+    const boundary = new Date(date.getTime());
+    boundary.setHours(23, 59, 59, 999);
+    return boundary;
+}
+function toIsoString(date) {
+    return date.toISOString();
+}
+function inferScheduleMode(schedule) {
+    const mode = get(schedule, 'mode');
+    if (mode === 'hourly' ||
+        mode === 'daily' ||
+        mode === 'weekly' ||
+        mode === 'monthly' ||
+        mode === 'yearly') {
+        return mode;
+    }
+    const recurrence = get(schedule, 'recurrence');
+    switch (recurrence) {
+        case 'hourly':
+            return 'hourly';
+        case 'daily':
+            return 'daily';
+        case 'weekly':
+            return 'weekly';
+        case 'monthly':
+            return 'monthly';
+        case 'yearly':
+            return 'yearly';
+        default:
+            return 'daily';
+    }
+}
+function resolveScheduleInterval(schedule) {
+    const interval = get(schedule, 'interval');
+    return isNumber(interval) && interval > 0 ? interval : 1;
+}
+/**
+ * Anchor date for the first work-order occurrence (now, byDate, or onDemand).
+ */
+function resolveScheduleAnchorDate(schedule, referenceDate = new Date()) {
+    if (!schedule) {
+        return undefined;
+    }
+    const startType = get(schedule, 'startCondition.type');
+    if (startType === 'onDemand') {
+        return undefined;
+    }
+    if (startType === 'now') {
+        return new Date(referenceDate.getTime());
+    }
+    const configuredStart = toDate(get(schedule, 'startCondition.startDate'));
+    if (configuredStart) {
+        return configuredStart;
+    }
+    return undefined;
+}
+function addScheduleInterval(anchor, mode, interval, step) {
+    const result = new Date(anchor.getTime());
+    const amount = step * interval;
+    switch (mode) {
+        case 'hourly':
+            result.setHours(result.getHours() + amount);
+            break;
+        case 'daily':
+            result.setDate(result.getDate() + amount);
+            break;
+        case 'weekly':
+            result.setDate(result.getDate() + amount * 7);
+            break;
+        case 'monthly':
+            result.setMonth(result.getMonth() + amount);
+            break;
+        case 'yearly':
+            result.setFullYear(result.getFullYear() + amount);
+            break;
+    }
+    return result;
+}
+function resolveOccurrenceScheduledEnd(scheduledStart, estimatedHours) {
+    if (!isNumber(estimatedHours) || estimatedHours <= 0) {
+        return undefined;
+    }
+    const end = new Date(scheduledStart.getTime());
+    end.setTime(end.getTime() + estimatedHours * 60 * 60 * 1000);
+    return toIsoString(end);
+}
+/**
+ * Resolves scheduled start dates for work orders from a maintenance plan schedule.
+ *
+ * - End `never`: first occurrence only (next ones are generated later).
+ * - End `afterOccurrences`: all occurrences up to the configured count.
+ * - End `byDate`: occurrences from anchor through end date (inclusive).
+ */
+function resolveWorkOrderScheduledStarts(schedule, referenceDate = new Date()) {
+    if (!schedule) {
+        return [];
+    }
+    const anchor = resolveScheduleAnchorDate(schedule, referenceDate);
+    if (!anchor) {
+        return [];
+    }
+    const mode = inferScheduleMode(schedule);
+    const interval = resolveScheduleInterval(schedule);
+    const endType = defaultTo(get(schedule, 'endCondition.type'), 'never');
+    if (endType === 'never') {
+        return [anchor];
+    }
+    if (endType === 'afterOccurrences') {
+        const count = Math.max(1, defaultTo(get(schedule, 'endCondition.occurrences'), 1));
+        return Array.from({ length: count }, (_, step) => addScheduleInterval(anchor, mode, interval, step));
+    }
+    if (endType === 'byDate') {
+        const endDate = toScheduleEndBoundary(get(schedule, 'endCondition.endDate'));
+        if (!endDate) {
+            return [anchor];
+        }
+        const starts = [];
+        for (let step = 0; step < MAX_BY_DATE_OCCURRENCES; step += 1) {
+            const occurrence = addScheduleInterval(anchor, mode, interval, step);
+            if (occurrence.getTime() > endDate.getTime()) {
+                break;
+            }
+            starts.push(occurrence);
+        }
+        return starts;
+    }
+    return [anchor];
+}
+function resolveWorkOrderOccurrences(schedule, options) {
+    const referenceDate = options?.referenceDate ?? new Date();
+    const starts = resolveWorkOrderScheduledStarts(schedule, referenceDate);
+    const estimatedHours = options?.estimatedHours;
+    if (starts.length === 0) {
+        return [{}];
+    }
+    return starts.map((scheduledStart) => {
+        const scheduledEnd = resolveOccurrenceScheduledEnd(scheduledStart, estimatedHours);
+        return {
+            scheduledStart: toIsoString(scheduledStart),
+            ...(scheduledEnd ? { scheduledEnd } : {}),
+        };
+    });
+}
+/**
+ * Returns how many work orders will be created from a plan schedule (minimum 1 when schedule is absent or on-demand).
+ */
+function countWorkOrdersToCreateFromSchedule(schedule, referenceDate = new Date()) {
+    return resolveWorkOrderOccurrences(schedule, { referenceDate }).length;
+}
+function resolveScheduledStart(schedule, referenceDate = new Date()) {
+    const starts = resolveWorkOrderScheduledStarts(schedule, referenceDate);
+    const first = starts[0];
+    return first ? toIsoString(first) : undefined;
+}
+/** Internal flag on plan create payloads; stripped before persistence when supported. */
+const SUPPRESS_WORK_ORDER_PROMPT_FIELD = '__suppressWorkOrderPrompt';
+/**
+ * Allocates and commits the next identifier code for programmatic entity creates.
+ * Validation runs before identifier middleware (order 5); the code must be on the payload.
+ * Uses `generate` (not `peek`) so back-to-back creates in a loop receive distinct codes.
+ */
+async function allocateIdentifierCode(identifierService, sessionService, ruleId) {
+    const result = await identifierService.generate({
+        id: ruleId,
+        tenantId: sessionService.tenant?.id,
+        appId: sessionService.application?.id,
+    });
+    return result.code;
+}
+function buildMaintenancePlanPayload(asset, template, options) {
+    return {
+        ...(options?.code ? { code: options.code } : {}),
+        title: combineMultiLanguageTitle(template.title, template.code ?? 'Template', asset.title, asset.code ?? 'Asset'),
+        description: template.description,
+        assetId: asset.id,
+        maintenanceTypeId: template.maintenanceTypeId,
+        maintenanceTemplateId: template.id,
+        schedule: template.schedule ?? {
+            startCondition: { type: 'byDate', startDate: new Date().toISOString() },
+        },
+        estimatedHours: template.estimatedMinutes
+            ? Math.max(1, Math.ceil(template.estimatedMinutes / 60))
+            : undefined,
+        needPermission: !!template.needPermission,
+        needShutdown: !!template.needShutdown,
+        ...(options?.autoGeneratedPlan ? { autoGeneratedPlan: true } : {}),
+        ...(options?.suppressWorkOrderPrompt
+            ? { [SUPPRESS_WORK_ORDER_PROMPT_FIELD]: true }
+            : {}),
+    };
+}
+async function resolveMaintenanceTemplate(backend, templateEntityName, partial) {
+    if (!partial?.id) {
+        return null;
+    }
+    if (partial.maintenanceTypeId) {
+        return partial;
+    }
+    const loaded = (await backend
+        .getOne(templateEntityName, partial.id)
+        .catch(() => null));
+    return loaded?.maintenanceTypeId ? loaded : null;
+}
+function resolveRelationId(value) {
+    if (isString(value)) {
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    if (isObject(value)) {
+        const id = get(value, 'id');
+        if (isString(id)) {
+            const trimmed = id.trim();
+            return trimmed || undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Normalizes lookup-style relation values on a plan to plain ids for work-order generation.
+ */
+function normalizePlanRelationIds(plan) {
+    return {
+        ...plan,
+        assetId: resolveRelationId(plan.assetId) ?? plan.assetId,
+        maintenanceTypeId: resolveRelationId(plan.maintenanceTypeId) ?? plan.maintenanceTypeId,
+        maintenanceTemplateId: resolveRelationId(plan.maintenanceTemplateId) ?? plan.maintenanceTemplateId,
+        assignedToId: resolveRelationId(plan.assignedToId) ?? plan.assignedToId,
+        priorityId: resolveRelationId(plan.priorityId) ?? resolveRelationId(plan.priority?.id) ?? plan.priorityId,
+    };
+}
+/**
+ * Merges persisted plan with create-time fields that may not be returned by `getOne` yet.
+ * Stored values win; missing work-order fields are filled from the create payload.
+ */
+function mergeMaintenancePlanForWorkOrder(createPayload, stored, id) {
+    if (!stored && !createPayload) {
+        return null;
+    }
+    const merged = {
+        ...(createPayload ?? {}),
+        ...(stored ?? {}),
+        id: stored?.id ?? id,
+    };
+    delete merged[SUPPRESS_WORK_ORDER_PROMPT_FIELD];
+    if (!createPayload) {
+        return normalizePlanRelationIds(merged);
+    }
+    const fillIfMissing = (key) => {
+        const storedValue = merged[key];
+        const createValue = createPayload[key];
+        const storedEmpty = storedValue === undefined ||
+            storedValue === null ||
+            (typeof storedValue === 'string' && storedValue.trim() === '');
+        if (storedEmpty && createValue !== undefined && createValue !== null) {
+            merged[key] = createValue;
+        }
+    };
+    fillIfMissing('assetId');
+    fillIfMissing('maintenanceTypeId');
+    fillIfMissing('maintenanceTemplateId');
+    fillIfMissing('schedule');
+    fillIfMissing('title');
+    fillIfMissing('description');
+    fillIfMissing('needPermission');
+    fillIfMissing('needShutdown');
+    fillIfMissing('assignedToId');
+    fillIfMissing('assignedTo');
+    fillIfMissing('priorityId');
+    fillIfMissing('priority');
+    fillIfMissing('estimatedHours');
+    return normalizePlanRelationIds(merged);
+}
+/**
+ * Normalizes plan priority for work-order payload.
+ */
+function resolvePlanPriorityId(plan) {
+    const priorityId = plan.priorityId?.trim() || plan.priority?.id?.trim();
+    return priorityId || undefined;
+}
+/**
+ * Normalizes plan estimated hours (supports numeric strings from forms/storage).
+ */
+function resolvePlanEstimatedHours(plan) {
+    const raw = plan.estimatedHours;
+    if (isNumber(raw) && raw >= 0) {
+        return raw;
+    }
+    if (isString(raw)) {
+        const parsed = Number(raw);
+        if (!Number.isNaN(parsed) && parsed >= 0) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+const EMPLOYEE_ENTITY = 'HumanCapitalManagement.Employee';
+/**
+ * Maintenance plan `assignedToId` stores Employee id; work order `assignedToId` expects Person id.
+ */
+async function resolvePlanAssignedToForWorkOrder(backend, plan) {
+    const employeeId = plan.assignedToId?.trim();
+    if (!employeeId) {
+        return {};
+    }
+    const employee = (await backend.getOne(EMPLOYEE_ENTITY, employeeId).catch(() => null));
+    const personId = employee?.personId?.trim() || employee?.person?.id?.trim();
+    if (!personId) {
+        return {};
+    }
+    const fullName = employee?.person?.fullName?.trim() || employee?.person?.displayName?.trim();
+    return {
+        assignedToId: personId,
+        assignedTo: fullName ? { id: personId, fullName } : { id: personId },
+    };
+}
+/**
+ * Resolves work-order assignment, priority, and estimated hours from a maintenance plan.
+ */
+async function resolvePlanFieldsForWorkOrder(backend, plan) {
+    const assignment = await resolvePlanAssignedToForWorkOrder(backend, plan);
+    const priorityId = resolvePlanPriorityId(plan);
+    const estimatedHours = resolvePlanEstimatedHours(plan);
+    return {
+        ...assignment,
+        ...(priorityId ? { priorityId } : {}),
+        ...(estimatedHours !== undefined ? { estimatedHours } : {}),
+    };
+}
+function buildWorkOrderPayloadFromFailureRegister(failureRegister, template, workOrderNo) {
+    const title = normalizeMultiLanguageString(template.title, template.code ?? 'Template');
+    return {
+        workOrderNo,
+        assetId: failureRegister.assetId,
+        maintenanceTypeId: template.maintenanceTypeId,
+        maintenanceTemplateId: template.id,
+        failureRegisterId: failureRegister.id,
+        priorityId: failureRegister.priorityId,
+        title,
+        description: failureRegister.description,
+        needPermission: !!template.needPermission,
+        needShutdown: !!template.needShutdown,
+        statusId: AXMWorkOrderStatus.Planned,
+        sourceType: AXMWorkOrderSourceType.FailureRegister,
+        isArchived: false,
+        isDeleted: false,
+    };
+}
+function buildWorkOrderPayloadFromPlan(plan, workOrderNo, options) {
+    const title = normalizeMultiLanguageString(plan.title, plan.code ?? 'Work order');
+    const occurrence = options?.occurrence ??
+        resolveWorkOrderOccurrences(plan.schedule, {
+            referenceDate: options?.referenceDate,
+            estimatedHours: resolvePlanEstimatedHours(plan),
+        })[0];
+    const fields = options?.workOrderFields ?? {};
+    const priorityId = fields.priorityId ?? resolvePlanPriorityId(plan);
+    const estimatedHours = fields.estimatedHours ?? resolvePlanEstimatedHours(plan);
+    return {
+        workOrderNo,
+        assetId: plan.assetId,
+        maintenanceTypeId: plan.maintenanceTypeId,
+        maintenanceTemplateId: plan.maintenanceTemplateId,
+        maintenancePlanId: plan.id,
+        title,
+        description: plan.description,
+        scheduledStart: occurrence?.scheduledStart,
+        ...(options?.includeScheduledEnd && occurrence?.scheduledEnd
+            ? { scheduledEnd: occurrence.scheduledEnd }
+            : {}),
+        ...(fields.assignedToId
+            ? {
+                assignedToId: fields.assignedToId,
+                ...(fields.assignedTo ? { assignedTo: fields.assignedTo } : {}),
+            }
+            : {}),
+        ...(priorityId ? { priorityId } : {}),
+        ...(estimatedHours !== undefined ? { estimatedHours } : {}),
+        needPermission: !!plan.needPermission,
+        needShutdown: !!plan.needShutdown,
+        ...(options?.autoGeneratedWorkOrder ? { autoGeneratedWorkOrder: true } : {}),
+        statusId: AXMWorkOrderStatus.Planned,
+        sourceType: options?.sourceType ?? AXMWorkOrderSourceType.MaintenancePlan,
+        isArchived: false,
+        isDeleted: false,
+    };
+}
+/**
+ * Builds one work-order payload per schedule occurrence (count varies by end condition).
+ */
+function buildWorkOrderPayloadsFromPlan(plan, options) {
+    const referenceDate = options?.referenceDate ?? new Date();
+    const estimatedHours = resolvePlanEstimatedHours(plan);
+    const occurrences = resolveWorkOrderOccurrences(plan.schedule, {
+        referenceDate,
+        estimatedHours,
+    });
+    const selectedOccurrences = options?.autoGeneratedWorkOrder ? occurrences.slice(0, 1) : occurrences;
+    return selectedOccurrences.map((occurrence) => buildWorkOrderPayloadFromPlan(plan, '', {
+        autoGeneratedWorkOrder: options?.autoGeneratedWorkOrder,
+        referenceDate,
+        occurrence,
+        sourceType: options?.sourceType,
+        workOrderFields: options?.workOrderFields,
+        includeScheduledEnd: options?.includeScheduledEnd,
+    }));
+}
+/**
+ * Inserts all work orders implied by the plan schedule (peek identifier per row).
+ */
+async function insertWorkOrdersFromPlan(entityStorage, identifierService, sessionService, workOrderEntityName, plan, options) {
+    const resolvedPlan = normalizePlanRelationIds(plan);
+    const workOrderFields = options?.backend ? await resolvePlanFieldsForWorkOrder(options.backend, resolvedPlan) : {};
+    const payloads = buildWorkOrderPayloadsFromPlan(resolvedPlan, {
+        autoGeneratedWorkOrder: options?.autoGeneratedWorkOrder,
+        referenceDate: options?.referenceDate,
+        sourceType: options?.sourceType,
+        workOrderFields,
+        includeScheduledEnd: false,
+    });
+    let createdCount = 0;
+    for (const payload of payloads) {
+        const workOrderNo = await allocateIdentifierCode(identifierService, sessionService, WORK_ORDER_NO_RULE_ID);
+        await entityStorage.insertOne(workOrderEntityName, { ...payload, workOrderNo });
+        createdCount += 1;
+    }
+    return createdCount;
+}
+function canCreateWorkOrderFromFailureRegister(failureRegister, template) {
+    return !!(failureRegister.assetId && template.id && template.maintenanceTypeId);
+}
+function canCreateWorkOrderFromPlan(plan) {
+    const normalized = normalizePlanRelationIds(plan);
+    return !!(normalized.assetId &&
+        normalized.maintenanceTypeId &&
+        normalized.maintenanceTemplateId);
+}
+function isMaintenanceTemplateLike(row) {
+    if (!row || typeof row !== 'object') {
+        return false;
+    }
+    const candidate = row;
+    return typeof candidate.id === 'string' && typeof candidate.maintenanceTypeId === 'string';
+}
+async function queryAutoGenerateTemplatesForAssetType(backend, templateEntityName, assetTypeId) {
+    const result = await backend
+        .query(templateEntityName, {
+        skip: 0,
+        take: 200,
+        filter: {
+            logic: 'and',
+            filters: [
+                { field: 'assetTypeId', operator: { type: 'equal' }, value: assetTypeId },
+                { field: 'autoGeneratePlan', operator: { type: 'equal' }, value: true },
+            ],
+        },
+    })
+        .catch(() => ({ total: 0, items: [] }));
+    const items = result.items ?? [];
+    return items.filter(isMaintenanceTemplateLike);
+}
+const ASSET_ENTITY$2 = 'AssetManagement.Asset';
+const ASSET_TYPE_ENTITY$1 = 'AssetManagement.AssetType';
+function isWorkflowEnabledOnTemplate(template) {
+    const config = template.workflowConfig;
+    if (!config?.workflowDefinitionId?.trim() || !config?.workflowName?.trim()) {
+        return false;
+    }
+    return config.enabled !== false;
+}
+/**
+ * Resolves asset → asset type maintenance types → maintenance templates with an enabled workflow.
+ */
+async function queryWorkflowTemplatesForAsset(backend, templateEntityName, assetId) {
+    const trimmedAssetId = assetId?.trim();
+    if (!trimmedAssetId) {
+        return [];
+    }
+    const asset = (await backend.getOne(ASSET_ENTITY$2, trimmedAssetId).catch(() => null));
+    const assetTypeId = asset?.assetTypeId?.trim();
+    if (!asset || !assetTypeId) {
+        return [];
+    }
+    const assetType = (await backend.getOne(ASSET_TYPE_ENTITY$1, assetTypeId).catch(() => null));
+    const maintenanceTypeIds = (assetType?.maintenanceTypeIds ?? []).filter((id) => isString(id) && id.trim());
+    if (maintenanceTypeIds.length === 0) {
+        return [];
+    }
+    const result = await backend
+        .query(templateEntityName, {
+        skip: 0,
+        take: 500,
+        filter: {
+            logic: 'and',
+            filters: [
+                { field: 'assetTypeId', operator: { type: 'equal' }, value: assetTypeId },
+                { field: 'maintenanceTypeId', operator: { type: 'in' }, value: maintenanceTypeIds },
+            ],
+        },
+    })
+        .catch(() => ({ total: 0, items: [] }));
+    const rawItems = result.items ?? [];
+    const items = rawItems.filter(isMaintenanceTemplateLike);
+    return items.filter((template) => isWorkflowEnabledOnTemplate(template));
+}
+async function hasWorkOrderForPlan(backend, workOrderEntityName, planId) {
+    const result = await backend
+        .query(workOrderEntityName, {
+        skip: 0,
+        take: 1,
+        filter: {
+            field: 'maintenancePlanId',
+            operator: { type: 'equal' },
+            value: planId,
+        },
+    })
+        .catch(() => ({ total: 0, items: [] }));
+    return (result.total ?? 0) > 0 || (result.items?.length ?? 0) > 0;
+}
+async function countWorkOrdersForMaintenancePlan(backend, workOrderEntityName, planId) {
+    const result = await backend
+        .query(workOrderEntityName, {
+        skip: 0,
+        take: 1,
+        filter: {
+            field: 'maintenancePlanId',
+            operator: { type: 'equal' },
+            value: planId,
+        },
+    })
+        .catch(() => ({ total: 0 }));
+    return result.total ?? 0;
+}
+async function hasWorkOrderForPlanScheduledStart(backend, workOrderEntityName, planId, scheduledStart) {
+    const result = await backend
+        .query(workOrderEntityName, {
+        skip: 0,
+        take: 1,
+        filter: {
+            logic: 'and',
+            filters: [
+                { field: 'maintenancePlanId', operator: { type: 'equal' }, value: planId },
+                { field: 'scheduledStart', operator: { type: 'equal' }, value: scheduledStart },
+            ],
+        },
+    })
+        .catch(() => ({ total: 0, items: [] }));
+    return (result.total ?? 0) > 0 || (result.items?.length ?? 0) > 0;
+}
+/**
+ * Resolves the next scheduled work-order occurrence after a signed-off work order.
+ * For `endCondition.type === 'never'`, returns the next interval from the signed-off scheduled start.
+ */
+function resolveNextWorkOrderOccurrenceAfterSignedOff(plan, signedOffWorkOrder, referenceDate = new Date()) {
+    const schedule = plan.schedule;
+    if (!schedule) {
+        return null;
+    }
+    const startType = get(schedule, 'startCondition.type');
+    if (startType === 'onDemand') {
+        return null;
+    }
+    const anchor = toDate(signedOffWorkOrder.scheduledStart) ?? resolveScheduleAnchorDate(schedule, referenceDate);
+    if (!anchor) {
+        return null;
+    }
+    const mode = inferScheduleMode(schedule);
+    const interval = resolveScheduleInterval(schedule);
+    const nextStart = addScheduleInterval(anchor, mode, interval, 1);
+    const endType = defaultTo(get(schedule, 'endCondition.type'), 'never');
+    if (endType === 'byDate') {
+        const endDate = toScheduleEndBoundary(get(schedule, 'endCondition.endDate'));
+        if (endDate && nextStart.getTime() > endDate.getTime()) {
+            return null;
+        }
+    }
+    const estimatedHours = resolvePlanEstimatedHours(plan);
+    const scheduledEnd = resolveOccurrenceScheduledEnd(nextStart, estimatedHours);
+    return {
+        scheduledStart: toIsoString(nextStart),
+        ...(scheduledEnd ? { scheduledEnd } : {}),
+    };
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Constants   ----
+const ASSET_ENTITY$1 = 'AssetManagement.Asset';
+async function askMaintenanceOfferChoice(dialogService, translateService, templateCount, assetTitle) {
+    const title = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.title');
+    const content = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.content', { params: { count: templateCount, assetTitle } });
+    const plansOnlyLabel = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.actions.plans-only');
+    const plansAndWorkOrdersLabel = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.actions.plans-and-work-orders');
+    const cancelLabel = await translateService.translateAsync('@general:actions.cancel.title');
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(value);
+        };
+        const dialog = dialogService.open({
+            title,
+            content,
+            type: 'primary',
+            orientation: 'horizontal',
+            closeButton: false,
+            buttons: [
+                {
+                    text: cancelLabel,
+                    color: 'default',
+                    autofocus: true,
+                    onClick: () => {
+                        dialog.close();
+                        finish(null);
+                    },
+                },
+                {
+                    text: plansOnlyLabel,
+                    color: 'default',
+                    onClick: () => {
+                        dialog.close();
+                        finish({ createPlans: true, createWorkOrders: false });
+                    },
+                },
+                {
+                    text: plansAndWorkOrdersLabel,
+                    color: 'primary',
+                    onClick: () => {
+                        dialog.close();
+                        finish({ createPlans: true, createWorkOrders: true });
+                    },
+                },
+            ],
+        });
+    });
+}
+//#endregion
+//#region ----   Middleware   ----
+/**
+ * After creating an Asset, offers to create maintenance plans (and optionally work orders)
+ * for maintenance templates on the asset type with `autoGeneratePlan = true`.
+ */
+const assetCreateMaintenanceOfferMiddleware = {
+    target: {
+        ops: ['create'],
+        order: 88,
+    },
+    execute: async (ctx, next) => {
+        const dialogService = inject(AXDialogService, { optional: true });
+        const toastService = inject(AXToastService, { optional: true });
+        const translateService = inject(AXTranslationService, { optional: true });
+        const backend = ctx.entities;
+        const entityStorage = inject(AXPEntityStorageService, { optional: true });
+        const identifierService = inject(AXP_IDENTIFIER_SERVICE, { optional: true });
+        const sessionService = inject(AXPSessionService, { optional: true });
+        if (ctx.entityName !== ASSET_ENTITY$1) {
+            await next();
+            return;
+        }
+        await next();
+        const createdId = typeof ctx.result === 'string' ? ctx.result : undefined;
+        if (!createdId ||
+            !dialogService ||
+            !toastService ||
+            !translateService ||
+            !entityStorage ||
+            !identifierService ||
+            !sessionService) {
+            return;
+        }
+        const asset = (await backend.getOne(ASSET_ENTITY$1, createdId).catch(() => null));
+        if (!asset?.assetTypeId) {
+            return;
+        }
+        const templateEntity = `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`;
+        const planEntity = `${RootConfig.module.name}.${RootConfig.entities.maintenancePlan.name}`;
+        const workOrderEntity = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+        const templates = await queryAutoGenerateTemplatesForAssetType(backend, templateEntity, asset.assetTypeId);
+        if (templates.length === 0) {
+            return;
+        }
+        const assetTitle = resolveDisplayLabel(asset.title, asset.code ?? createdId);
+        const choice = await askMaintenanceOfferChoice(dialogService, translateService, templates.length, assetTitle);
+        if (!choice?.createPlans) {
+            return;
+        }
+        const createdPlans = [];
+        for (const template of templates) {
+            if (!template.maintenanceTypeId) {
+                const loaded = (await backend
+                    .getOne(templateEntity, template.id)
+                    .catch(() => null));
+                if (!loaded?.maintenanceTypeId) {
+                    continue;
+                }
+                Object.assign(template, loaded);
+            }
+            try {
+                // Validation runs before identifier middleware; allocate (commit) a distinct code per plan.
+                const planCode = await allocateIdentifierCode(identifierService, sessionService, MAINTENANCE_PLAN_CODE_RULE_ID);
+                const planPayload = buildMaintenancePlanPayload(asset, template, {
+                    suppressWorkOrderPrompt: true,
+                    code: planCode,
+                    autoGeneratedPlan: true,
+                });
+                const planId = await entityStorage.insertOne(planEntity, planPayload);
+                const resolvedPlanId = typeof planId === 'string' ? planId : undefined;
+                if (!resolvedPlanId) {
+                    continue;
+                }
+                const storedPlan = (await backend.getOne(planEntity, resolvedPlanId).catch(() => null));
+                const plan = mergeMaintenancePlanForWorkOrder({ ...planPayload, id: resolvedPlanId }, storedPlan, resolvedPlanId);
+                if (plan) {
+                    createdPlans.push(plan);
+                }
+            }
+            catch (error) {
+                const errorTitle = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.errors.create-failed-title');
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.errors.create-failed-content');
+                toastService.show({ color: 'danger', title: errorTitle, content: errorMessage });
+                return;
+            }
+        }
+        if (!choice.createWorkOrders || createdPlans.length === 0) {
+            const successTitle = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.success.plans-title');
+            const successContent = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.success.plans-content', { params: { count: createdPlans.length } });
+            toastService.show({ color: 'success', title: successTitle, content: successContent });
+            return;
+        }
+        let workOrderCount = 0;
+        const referenceDate = new Date();
+        for (const plan of createdPlans) {
+            if (!canCreateWorkOrderFromPlan(plan)) {
+                continue;
+            }
+            workOrderCount += await insertWorkOrdersFromPlan(entityStorage, identifierService, sessionService, workOrderEntity, plan, {
+                autoGeneratedWorkOrder: true,
+                referenceDate,
+                sourceType: AXMWorkOrderSourceType.CreateAsset,
+                backend,
+            });
+        }
+        const successTitle = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.success.both-title');
+        const successContent = await translateService.translateAsync('@asset-management:assets.entities.asset.dialogs.create-maintenance-offer.success.both-content', { params: { planCount: createdPlans.length, workOrderCount } });
+        toastService.show({ color: 'success', title: successTitle, content: successContent });
+    },
+};
+//#endregion
+
+//#region ----   Imports   ----
+/** Asset detail route entity keys (must match AssetManagement registration). */
+const ASSET_ENTITY = 'AssetManagement.Asset';
+const ASSET_TYPE_ENTITY = 'AssetManagement.AssetType';
+//#endregion
+//#region ----   Helpers   ----
+function normalizeMaintenanceTypeIds(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((id) => typeof id === 'string' && id.trim().length > 0);
+}
+/**
+ * Resolves maintenance type ids allowed for the asset (from asset type), matching work-order / maintenance-plan lookups.
+ */
+async function resolveAssetMaintenanceTypeIds(backend, assetId) {
+    const asset = (await backend.getOne(ASSET_ENTITY, assetId).catch(() => null));
+    if (!asset) {
+        return [];
+    }
+    const fromAssetType = normalizeMaintenanceTypeIds(asset.assetType?.maintenanceTypeIds);
+    if (fromAssetType.length > 0) {
+        return fromAssetType;
+    }
+    if (!asset.assetTypeId) {
+        return [];
+    }
+    const assetType = (await backend
+        .getOne(ASSET_TYPE_ENTITY, asset.assetTypeId)
+        .catch(() => null));
+    return normalizeMaintenanceTypeIds(assetType?.maintenanceTypeIds);
+}
+//#endregion
+//#region ----   Middleware   ----
+/**
+ * After creating a Failure Register, asks user to optionally create a Work Order.
+ * If user confirms, opens the standard entity data selector for maintenance templates.
+ */
+const failureRegisterCreateWorkOrderMiddleware = {
+    target: {
+        ops: ['create'],
+        order: 90,
+    },
+    execute: async (ctx, next) => {
+        // IMPORTANT: resolve injected deps before any await to keep Angular injection context valid.
+        const dialogService = inject(AXDialogService, { optional: true });
+        const toastService = inject(AXToastService, { optional: true });
+        const entityRegistry = inject(AXPEntityDefinitionRegistryService, { optional: true });
+        const entityDataSelector = inject(AXPEntityDataSelectorService, { optional: true });
+        const backend = ctx.entities;
+        const entityStorage = inject(AXPEntityStorageService, { optional: true });
+        const identifierService = inject(AXP_IDENTIFIER_SERVICE, { optional: true });
+        const sessionService = inject(AXPSessionService, { optional: true });
+        const failureRegisterEntity = `${RootConfig.module.name}.${RootConfig.entities.failureRegister.name}`;
+        if (ctx.entityName !== failureRegisterEntity) {
+            await next();
+            return;
+        }
+        await next();
+        const createdId = typeof ctx.result === 'string' ? ctx.result : undefined;
+        if (!createdId) {
+            return;
+        }
+        // The middleware can run in non-UI execution contexts; keep it safe.
+        if (!dialogService ||
+            !toastService ||
+            !entityRegistry ||
+            !entityDataSelector ||
+            !entityStorage ||
+            !identifierService ||
+            !sessionService) {
+            return;
+        }
+        const fr = (await backend.getOne(ctx.entityName, createdId).catch(() => null));
+        if (!fr?.assetId) {
+            return;
+        }
+        const confirm = await dialogService.confirm('Create work order', 'Do you want to create work order now?', 'warning', 'horizontal', false, 'cancel');
+        if (confirm.result !== true) {
+            return;
+        }
+        const templateEntity = await entityRegistry.resolve(RootConfig.module.name, RootConfig.entities.maintenanceTemplate.name);
+        if (!templateEntity) {
+            toastService.show({
+                color: 'danger',
+                title: 'Template error',
+                content: 'Maintenance template entity is not available.',
+            });
+            return;
+        }
+        const maintenanceTypeIds = await resolveAssetMaintenanceTypeIds(backend, fr.assetId);
+        if (!maintenanceTypeIds.length) {
+            toastService.show({
+                color: 'warning',
+                title: 'No maintenance types',
+                content: 'The selected asset has no maintenance types configured on its asset type.',
+            });
+            return;
+        }
+        const selectorTitle = typeof templateEntity.title === 'string' ? templateEntity.title : RootConfig.entities.maintenanceTemplate.title;
+        const templateFilters = {
+            field: 'maintenanceTypeId',
+            operator: { type: 'in' },
+            value: maintenanceTypeIds,
+        };
+        const templateEntityName = `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`;
+        const workOrderEntityName = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+        const selectorResult = await entityDataSelector.open({
+            entity: templateEntity,
+            title: selectorTitle,
+            allowMultiple: false,
+            allowCreate: 'none',
+            columns: [
+                'code',
+                'title',
+                'maintenanceTypeId',
+                'needPermission',
+                'needShutdown',
+                'estimatedHours',
+                'hasSchedule',
+                'schedule',
+                'autoGeneratePlan',
+            ],
+            filters: templateFilters,
+        });
+        if (!selectorResult?.items?.length) {
+            return;
+        }
+        const selectedTemplate = selectorResult.items[0];
+        const template = await resolveMaintenanceTemplate(backend, templateEntityName, selectedTemplate);
+        if (!template) {
+            toastService.show({
+                color: 'danger',
+                title: 'Template error',
+                content: 'Selected template does not have maintenance type.',
+            });
+            return;
+        }
+        if (!canCreateWorkOrderFromFailureRegister(fr, template)) {
+            toastService.show({
+                color: 'warning',
+                title: 'Missing data',
+                content: 'Asset, maintenance type, and maintenance template are required to create a work order.',
+            });
+            return;
+        }
+        const workOrderNo = await allocateIdentifierCode(identifierService, sessionService, WORK_ORDER_NO_RULE_ID);
+        const result = await entityStorage.insertOne(workOrderEntityName, buildWorkOrderPayloadFromFailureRegister(fr, template, workOrderNo));
+        const workOrderId = typeof result === 'string' ? result : undefined;
+        if (!workOrderId) {
+            toastService.show({
+                color: 'danger',
+                title: 'Work order error',
+                content: 'Work order creation failed.',
+            });
+            return;
+        }
+        toastService.show({
+            color: 'success',
+            title: 'Work order created',
+            content: 'Work order was created successfully.',
+        });
+    },
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Constants   ----
+/** Per-create ctx.locals flag so duplicate middleware entries schedule only one prompt. */
+const WORK_ORDER_PROMPT_SCHEDULED_KEY = 'maintenancePlan.workOrderPromptScheduled';
+//#endregion
+//#region ----   Prompt runner   ----
+/**
+ * Asks whether to create work order(s) immediately after plan create completes.
+ * Runs inline after `next()` so the dialog appears before navigation away from the create form.
+ */
+async function runMaintenancePlanWorkOrderPrompt(deps) {
+    const { createdId, planEntity, createPayload, dialogService, backend, entityStorage, identifierService, sessionService, toastService, } = deps;
+    const storedPlan = (await backend.getOne(planEntity, createdId).catch(() => null));
+    const plan = mergeMaintenancePlanForWorkOrder(createPayload, storedPlan, createdId);
+    if (!plan) {
+        return;
+    }
+    const plannedWorkOrderCount = countWorkOrdersToCreateFromSchedule(plan.schedule);
+    const confirmMessage = plannedWorkOrderCount === 1
+        ? 'Do you want to create 1 work order now based on the plan schedule?'
+        : `Do you want to create ${plannedWorkOrderCount} work orders now based on the plan schedule?`;
+    const confirm = await dialogService.confirm('Create work order', confirmMessage, 'warning', 'horizontal', false, 'cancel');
+    if (confirm.result !== true) {
+        return;
+    }
+    if (!canCreateWorkOrderFromPlan(plan)) {
+        await dialogService.alert('Missing plan data', 'Asset, maintenance type, and maintenance template are required to create a work order.', 'warning');
+        return;
+    }
+    const workOrderEntity = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+    if (await hasWorkOrderForPlan(backend, workOrderEntity, plan.id)) {
+        await dialogService.alert('Work order exists', 'A work order already exists for this maintenance plan.', 'warning');
+        return;
+    }
+    try {
+        const workOrderCount = await insertWorkOrdersFromPlan(entityStorage, identifierService, sessionService, workOrderEntity, plan, { backend });
+        if (workOrderCount === 0) {
+            await dialogService.alert('Work order error', 'Work order creation failed.', 'danger');
+            return;
+        }
+        const successMessage = workOrderCount === 1
+            ? 'Work order was created successfully.'
+            : `${workOrderCount} work orders were created successfully.`;
+        toastService.show({
+            color: 'success',
+            title: 'Work order created',
+            content: successMessage,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Work order creation failed.';
+        await dialogService.alert('Work order error', message, 'danger');
+    }
+}
+//#endregion
+//#region ----   Middleware   ----
+/**
+ * After creating a Maintenance Plan, asks whether to create a Work Order immediately.
+ * If confirmed, creates Work Order using the plan's already selected template.
+ */
+const maintenancePlanCreateWorkOrderMiddleware = {
+    target: {
+        ops: ['create'],
+        order: 91,
+    },
+    execute: async (ctx, next) => {
+        const dialogService = inject(AXDialogService, { optional: true });
+        const toastService = inject(AXToastService, { optional: true });
+        const backend = ctx.entities;
+        const entityStorage = inject(AXPEntityStorageService, { optional: true });
+        const identifierService = inject(AXP_IDENTIFIER_SERVICE, { optional: true });
+        const sessionService = inject(AXPSessionService, { optional: true });
+        const maintenancePlanEntity = `${RootConfig.module.name}.${RootConfig.entities.maintenancePlan.name}`;
+        if (ctx.entityName !== maintenancePlanEntity) {
+            await next();
+            return;
+        }
+        const suppressPrompt = ctx.data &&
+            typeof ctx.data === 'object' &&
+            ctx.data[SUPPRESS_WORK_ORDER_PROMPT_FIELD] === true;
+        const createPayload = ctx.data && typeof ctx.data === 'object' ? ctx.data : undefined;
+        await next();
+        const createdId = typeof ctx.result === 'string' ? ctx.result : undefined;
+        if (!createdId ||
+            !dialogService ||
+            !toastService ||
+            !entityStorage ||
+            !identifierService ||
+            !sessionService ||
+            suppressPrompt) {
+            return;
+        }
+        if (ctx.locals.get(WORK_ORDER_PROMPT_SCHEDULED_KEY)) {
+            return;
+        }
+        ctx.locals.set(WORK_ORDER_PROMPT_SCHEDULED_KEY, true);
+        await runMaintenancePlanWorkOrderPrompt({
+            createdId,
+            planEntity: ctx.entityName,
+            createPayload,
+            dialogService,
+            backend,
+            entityStorage,
+            identifierService,
+            sessionService,
+            toastService,
+        });
+    },
+};
+//#endregion
+
+//#region ---- Constants ----
+/** Answer keys pre-filled from asset.code (readonly in viewer). */
+const WORK_ORDER_CHECKLIST_ASSET_CODE_KEYS = [
+    'mm_f920_asset_no',
+    'mm_prestart_plant_item',
+];
+/** Answer keys pre-filled from asset.serialNumber (readonly in viewer). */
+const WORK_ORDER_CHECKLIST_ASSET_SERIAL_KEYS = [
+    'mm_f920_registration_number',
+    'mm_prestart_serial_number',
+];
+/** All asset-driven prefill keys across maintenance checklists. */
+const WORK_ORDER_CHECKLIST_ASSET_PREFILL_KEYS = [
+    ...WORK_ORDER_CHECKLIST_ASSET_CODE_KEYS,
+    ...WORK_ORDER_CHECKLIST_ASSET_SERIAL_KEYS,
+];
+//#endregion
+//#region ---- Helpers ----
+/**
+ * Builds checklist answer prefill from asset identifiers for maintenance questionnaires.
+ */
+function buildWorkOrderChecklistAssetPrefillAnswers(asset) {
+    const code = typeof asset.code === 'string' ? asset.code.trim() : '';
+    const serialNumber = typeof asset.serialNumber === 'string' ? asset.serialNumber.trim() : '';
+    const answers = {};
+    if (code) {
+        for (const key of WORK_ORDER_CHECKLIST_ASSET_CODE_KEYS) {
+            answers[key] = code;
+        }
+    }
+    if (serialNumber) {
+        for (const key of WORK_ORDER_CHECKLIST_ASSET_SERIAL_KEYS) {
+            answers[key] = serialNumber;
+        }
+    }
+    return answers;
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Types ----
+const WORK_ORDER_SUBJECT_TYPE$1 = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+//#endregion
+//#region ---- Middleware ----
+/**
+ * Pre-fills PD-F920 asset header answers when a work-order checklist is opened from the task board.
+ */
+const workOrderChecklistFillMiddleware = async (context, next) => {
+    const entityService = inject(AXPEntityService);
+    const input = context.input;
+    const caseId = resolveText$1(get(input, 'caseId'));
+    if (!caseId) {
+        return next(context);
+    }
+    const assessmentCase = await entityService
+        .withEntity('AssessmentManagement', 'AssessmentCase')
+        .data()
+        .byKey(caseId);
+    const subjectType = resolveText$1(get(assessmentCase, 'subjectRef.type'));
+    const workOrderId = resolveText$1(get(assessmentCase, 'subjectRef.id'));
+    if (subjectType !== WORK_ORDER_SUBJECT_TYPE$1 || !workOrderId) {
+        return next(context);
+    }
+    const workOrder = await entityService
+        .withEntity(RootConfig.module.name, RootConfig.entities.workOrder.name)
+        .data()
+        .byKey(workOrderId);
+    const assetId = resolveText$1(get(workOrder, 'assetId'));
+    if (!assetId) {
+        return next(context);
+    }
+    const asset = (await entityService.withEntity('AssetManagement', 'Asset').data().byKey(assetId));
+    const prefillAnswers = buildWorkOrderChecklistAssetPrefillAnswers({
+        code: asset?.code ?? null,
+        serialNumber: asset?.serialNumber ?? null,
+    });
+    if (isEmpty(prefillAnswers)) {
+        return next(context);
+    }
+    const sessionId = resolveText$1(get(input, 'sessionId'));
+    if (sessionId) {
+        const session = await entityService.withEntity('AssessmentManagement', 'AssessmentSession').data().byKey(sessionId);
+        const existingAnswers = defaultTo(get(session, 'answers'), {});
+        const { merged, changed } = mergeMissingAnswers(existingAnswers, prefillAnswers);
+        if (changed) {
+            await entityService
+                .withEntity('AssessmentManagement', 'AssessmentSession')
+                .data()
+                .update(sessionId, { answers: merged });
+        }
+    }
+    return next({
+        ...context,
+        input: {
+            ...input,
+            prefillAnswers: {
+                ...prefillAnswers,
+                ...defaultTo(get(input, 'prefillAnswers'), {}),
+            },
+            readonlyAnswerKeys: [
+                ...WORK_ORDER_CHECKLIST_ASSET_PREFILL_KEYS,
+                ...defaultTo(get(input, 'readonlyAnswerKeys'), []),
+            ],
+        },
+    });
+};
+//#endregion
+//#region ---- Helpers ----
+function resolveText$1(value) {
+    if (!isString(value)) {
+        return '';
+    }
+    return value.trim();
+}
+function mergeMissingAnswers(existing, prefill) {
+    const merged = { ...existing };
+    let changed = false;
+    for (const [key, value] of Object.entries(prefill)) {
+        if (isEmpty(merged[key]) && !isEmpty(value)) {
+            merged[key] = value;
+            changed = true;
+        }
+    }
+    return { merged, changed };
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Types ----
+const WORK_ORDER_SUBJECT_TYPE = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+//#endregion
+//#region ---- Middleware ----
+/**
+ * After a work-order checklist is submitted, ensures WorkReport draft, assessment reference,
+ * and work-order in-progress status are persisted even when the workflow backend chain does not run.
+ */
+const workOrderChecklistPostSubmitMiddleware = async (context, next) => {
+    const entityService = inject(AXPEntityService);
+    const commandService = inject(AXPCommandService);
+    const sessionService = inject(AXPSessionService);
+    const result = await next(context);
+    try {
+        await applyWorkOrderChecklistPostSubmitEffects(context.input, result, {
+            entityService,
+            commandService,
+            sessionService,
+        });
+    }
+    catch (error) {
+        AXPDebugService.instance?.error('maintenance-management', 'work-order-checklist-post-submit', 'Post-submit middleware failed; assessment fill result preserved', () => ({
+            caseId: get(context.input, 'caseId'),
+            sessionId: get(context.input, 'sessionId'),
+            success: result?.success,
+            outcome: get(result, 'metadata.outcome'),
+            error: error instanceof Error ? error.message : String(error),
+        }));
+    }
+    return result;
+};
+//#endregion
+//#region ---- Post-submit effects ----
+async function applyWorkOrderChecklistPostSubmitEffects(input, result, services) {
+    if (!result?.success) {
+        return;
+    }
+    const caseId = resolveText(get(input, 'caseId'));
+    if (!caseId) {
+        return;
+    }
+    const submitted = await isWorkOrderChecklistSubmitted(input, result, caseId, services.entityService);
+    if (!submitted) {
+        return;
+    }
+    const { entityService, commandService, sessionService } = services;
+    const assessmentCase = await entityService
+        .withEntity('AssessmentManagement', 'AssessmentCase')
+        .data()
+        .byKey(caseId);
+    const subjectType = resolveText(get(assessmentCase, 'subjectRef.type'));
+    const workOrderId = resolveText(get(assessmentCase, 'subjectRef.id'));
+    if (subjectType !== WORK_ORDER_SUBJECT_TYPE || !workOrderId) {
+        return;
+    }
+    const workOrder = (await entityService
+        .withEntity(RootConfig.module.name, RootConfig.entities.workOrder.name)
+        .data()
+        .byKey(workOrderId));
+    if (!workOrder?.id) {
+        return;
+    }
+    const performedById = await resolveEmployeeIdByPersonId(entityService, resolveText(workOrder.assignedToId));
+    const completedById = resolveText(sessionService.user?.id);
+    const activityKeys = AXMMaintenanceManagementCommandKeys.WorkflowActivity;
+    const draftResult = await commandService.execute(activityKeys.CreateOrGetWorkReportDraft, {
+        workOrderId,
+        performedById: performedById || null,
+    });
+    const workReportId = resolveText(get(draftResult, 'data.workReportId'));
+    await commandService.execute(activityKeys.RecordWorkReportAssessment, {
+        workOrderId,
+        workReportId: workReportId || null,
+        performedById: performedById || null,
+        assessmentCaseId: caseId,
+        completedById: completedById || null,
+    });
+    const shouldSetInProgress = workOrder.statusId === AXMWorkOrderStatus.Planned ||
+        workOrder.statusId === AXMWorkOrderStatus.Scheduled ||
+        workOrder.statusId === AXMWorkOrderStatus.Assigned;
+    if (shouldSetInProgress) {
+        await commandService.execute(activityKeys.UpdateWorkOrderInProgress, { workOrderId });
+    }
+}
+async function isWorkOrderChecklistSubmitted(input, result, caseId, entityService) {
+    const outcome = resolveText(get(result, 'metadata.outcome')).toLowerCase();
+    if (outcome === 'submitted') {
+        return true;
+    }
+    const sessionId = resolveText(get(input, 'sessionId'));
+    if (sessionId) {
+        const session = await entityService
+            .withEntity('AssessmentManagement', 'AssessmentSession')
+            .data()
+            .byKey(sessionId);
+        if (resolveText(get(session, 'statusId')).toLowerCase() === 'submitted') {
+            return true;
+        }
+    }
+    const page = await entityService
+        .withEntity('AssessmentManagement', 'AssessmentSession')
+        .data()
+        .query({
+        skip: 0,
+        take: 1,
+        sort: [{ field: 'lastSavedAt', direction: 'desc' }],
+        filter: {
+            logic: 'and',
+            filters: [{ field: 'caseId', operator: { type: 'equal' }, value: caseId }],
+        },
+    });
+    const latest = defaultTo(get(page, 'items[0]'), null);
+    return resolveText(latest?.statusId).toLowerCase() === 'submitted';
+}
+async function resolveEmployeeIdByPersonId(entityService, personId) {
+    if (!personId) {
+        return '';
+    }
+    const page = await entityService
+        .withEntity('HumanCapitalManagement', 'Employee')
+        .data()
+        .query({
+        skip: 0,
+        take: 1,
+        filter: {
+            logic: 'and',
+            filters: [{ field: 'personId', operator: { type: 'equal' }, value: personId }],
+        },
+    });
+    const employee = defaultTo(get(page, 'items[0]'), null);
+    return resolveText(employee?.id);
+}
+function resolveText(value) {
+    if (!isString(value)) {
+        return '';
+    }
+    return value.trim();
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Middleware   ----
+const workOrderEntityName = `${RootConfig.module.name}.${RootConfig.entities.workOrder.name}`;
+/**
+ * Applies create defaults for work orders: `sourceType` (manual when unset) and `requestedById` (current user).
+ */
+const workOrderSourceTypeMiddleware = {
+    target: {
+        ops: ['create'],
+        order: 10,
+    },
+    execute: async (ctx, next) => {
+        if (ctx.entityName !== workOrderEntityName || !ctx.data || typeof ctx.data !== 'object') {
+            await next();
+            return;
+        }
+        const data = ctx.data;
+        if (isNil(data['sourceType']) || data['sourceType'] === '') {
+            data['sourceType'] = AXMWorkOrderSourceType.Manual;
+        }
+        const sessionService = inject(AXPSessionService, { optional: true });
+        const currentUserId = sessionService?.user?.id;
+        if (!isEmpty(currentUserId)) {
+            data['requestedById'] = currentUserId;
+        }
+        await next();
+    },
+};
+//#endregion
+
+//#region ----   Middleware Exports   ----
+//#endregion
+
+//#endregion
+//#region ---- Constants ----
+const QUESTIONNAIRE = 'AssessmentManagement.Questionnaire';
+const QUESTION_BANK_ITEM = 'AssessmentManagement.QuestionBankItem';
+const WORKFLOW_DEFINITION = 'WorkflowManagement.WorkflowDefinition';
+const MM_CATALOG_TARGETS = [QUESTIONNAIRE, QUESTION_BANK_ITEM, WORKFLOW_DEFINITION];
+//#endregion
+//#region ---- Provider ----
+class AXMMaintenanceManagementCatalogScopeDefinitionProvider {
+    async items() {
+        return [
+            {
+                name: MM_CATALOG_SCOPE_MN,
+                title: '@maintenance-management:catalog-scopes.mn.title',
+                description: '@maintenance-management:catalog-scopes.mn.description',
+                targets: [...MM_CATALOG_TARGETS],
+                icon: 'fa-light fa-screwdriver-wrench',
+                cssClass: 'warning-surface',
+                order: 20,
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementCatalogScopeDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementCatalogScopeDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Helpers ----
+function resolveAssetId(value) {
+    if (!isString(value)) {
+        return '';
+    }
+    return value.trim();
+}
+//#endregion
+/**
+ * Expression-evaluator scope for work-order "Create" dropdown items (workflow-enabled maintenance templates).
+ */
+class AXMMaintenanceManagementWorkOrderExpressionEvaluatorScopeProvider {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+        this.translation = inject(AXTranslationService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- AXPExpressionEvaluatorScopeProvider ----
+    async provide(context) {
+        context.addScope(RootConfig.module.name, {
+            /**
+             * Loads maintenance templates with workflows for the asset behind the current list context.
+             * Resolves asset → assetType.maintenanceTypeIds → templates (assetType + maintenanceType + workflow).
+             */
+            WorkOrderCreateActions: async (assetIdRaw) => {
+                const assetId = resolveAssetId(assetIdRaw);
+                if (!assetId) {
+                    return [];
+                }
+                try {
+                    const locale = this.translation.getActiveLang();
+                    const backend = this.createStorageBackend();
+                    const assetContext = await this.loadAssetMaintenanceContext(backend, assetId);
+                    if (!assetContext) {
+                        return [];
+                    }
+                    const templateEntityName = `${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`;
+                    const templates = await queryWorkflowTemplatesForAsset(backend, templateEntityName, assetId);
+                    const sorted = [...templates].sort((a, b) => {
+                        const ta = resolveDisplayLabel(a.title, a.code ?? a.id, locale);
+                        const tb = resolveDisplayLabel(b.title, b.code ?? b.id, locale);
+                        return ta.localeCompare(tb, locale, { sensitivity: 'base' });
+                    });
+                    const { asset, assetTypeId, maintenanceTypeIds } = assetContext;
+                    return sorted.map((template) => ({
+                        name: `create-work-order-${template.id}`,
+                        title: resolveDisplayLabel(template.title, template.code ?? template.id, locale),
+                        icon: 'fa-light fa-clipboard-list',
+                        color: 'default',
+                        command: {
+                            name: 'Entity:Create',
+                            options: {
+                                process: {
+                                    redirect: false,
+                                    canCreateNewOne: true,
+                                    data: {
+                                        assetId: asset.id,
+                                        asset: {
+                                            id: asset.id,
+                                            title: asset.title,
+                                            assetTypeId,
+                                            assetType: { maintenanceTypeIds },
+                                        },
+                                        maintenanceTypeId: template.maintenanceTypeId,
+                                        maintenanceTemplateId: template.id,
+                                        maintenanceTemplate: {
+                                            id: template.id,
+                                            title: template.title,
+                                            metadataIds: template.metadataIds,
+                                            workflowConfig: template.workflowConfig,
+                                        },
+                                        needShutdown: template.needShutdown ?? false,
+                                        needPermission: template.needPermission ?? false,
+                                        estimatedHours: typeof template.estimatedMinutes === 'number' && template.estimatedMinutes > 0
+                                            ? Math.round((template.estimatedMinutes / 60) * 100) / 100
+                                            : undefined,
+                                        sourceType: AXMWorkOrderSourceType.Manual,
+                                        autoGeneratedWorkOrder: false,
+                                    },
+                                },
+                            },
+                        },
+                        priority: 'primary',
+                        type: 'info',
+                        scope: AXPEntityCommandScope.TypeLevel,
+                    }));
+                }
+                catch (error) {
+                    console.error(`${RootConfig.module.name}.WorkOrderCreateActions failed:`, error instanceof Error ? error.message : error);
+                    return [];
+                }
+            },
+        });
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    createStorageBackend() {
+        return {
+            getOne: async (entityName, id) => {
+                const [module, entity] = entityName.split('.');
+                return this.entityService.withEntity(module, entity).data().byKey(id);
+            },
+            insertOne: async () => null,
+            query: async (entityName, request) => {
+                const [module, entity] = entityName.split('.');
+                return this.entityService.withEntity(module, entity).data().query(request);
+            },
+        };
+    }
+    async loadAssetMaintenanceContext(backend, assetId) {
+        const asset = (await backend.getOne('AssetManagement.Asset', assetId));
+        const assetTypeId = asset?.assetTypeId?.trim();
+        if (!asset?.id || !assetTypeId) {
+            return null;
+        }
+        const assetType = (await backend.getOne('AssetManagement.AssetType', assetTypeId));
+        const maintenanceTypeIds = (assetType?.maintenanceTypeIds ?? []).filter((id) => isString(id) && id.trim());
+        if (maintenanceTypeIds.length === 0) {
+            return null;
+        }
+        return {
+            asset: { id: asset.id, title: asset.title, assetTypeId },
+            assetTypeId,
+            maintenanceTypeIds,
+        };
+    }
+}
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Widget config ----
+const AXMWorkOrderWorkflowColumnWidget = {
+    name: 'work-order-workflow-column',
+    title: 'Work Order Workflow Column',
+    description: 'List column for selecting a maintenance template workflow and starting the flow per row.',
+    type: 'view',
+    categories: [],
+    groups: [AXPWidgetGroupEnum.EntityWidget],
+    icon: 'fa-light fa-diagram-project',
+    properties: [],
+    components: {
+        column: {
+            component: () => import('./acorex-platform-module-maintenance-management-client-work-order-workflow-column.component-Dth3Z9fW.mjs').then((c) => c.AXMWorkOrderWorkflowColumnComponent),
+        },
+    },
+};
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Widget config ----
+const AXMWorkOrderWorkReportColumnWidget = {
+    name: 'work-order-work-report-column',
+    title: 'Work Order Work Report Column',
+    description: 'List column for viewing the work report linked to a work order.',
+    type: 'view',
+    categories: [],
+    groups: [AXPWidgetGroupEnum.EntityWidget],
+    icon: 'fa-light fa-file-lines',
+    properties: [],
+    components: {
+        column: {
+            component: () => import('./acorex-platform-module-maintenance-management-client-work-order-work-report-column.component-Bf1WZWIS.mjs').then((c) => c.AXMWorkOrderWorkReportColumnComponent),
+        },
+    },
+};
+//#endregion
+
+//#endregion
+//#region ---- Provider ----
+class AXMWorkOrderWorkflowColumnWidgetProvider {
+    getWidgets() {
+        return [AXMWorkOrderWorkflowColumnWidget, AXMWorkOrderWorkReportColumnWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkOrderWorkflowColumnWidgetProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkOrderWorkflowColumnWidgetProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkOrderWorkflowColumnWidgetProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Widget config ----
+const AXMWorkReportChecklistResultsWidget = {
+    name: 'work-report-checklist-results',
+    title: 'Work Report Checklist Results',
+    description: 'Read-only checklist assessment references with view-response actions.',
+    type: 'view',
+    categories: [],
+    groups: [AXPWidgetGroupEnum.EntityWidget],
+    icon: 'fa-light fa-list-check',
+    properties: [],
+    components: {
+        view: {
+            component: () => import('./acorex-platform-module-maintenance-management-client-work-report-checklist-results-view.component-BSFW0Yt-.mjs').then((c) => c.AXMWorkReportChecklistResultsViewComponent),
+        },
+        edit: {
+            component: () => import('./acorex-platform-module-maintenance-management-client-work-report-checklist-results-view.component-BSFW0Yt-.mjs').then((c) => c.AXMWorkReportChecklistResultsViewComponent),
+        },
+    },
+};
+//#endregion
+
+//#endregion
+//#region ---- Provider ----
+class AXMWorkReportWidgetProvider {
+    getWidgets() {
+        return [AXMWorkReportChecklistResultsWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkReportWidgetProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkReportWidgetProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMWorkReportWidgetProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMMaintenanceManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: MaintenanceManagementManifest,
+                multi: true,
+            },
+            {
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMMaintenanceManagementCatalogScopeDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMMaintenanceManagementWorkOrderExpressionEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMWorkReportWidgetProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMWorkOrderWorkflowColumnWidgetProvider,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMMaintenanceManagementPermissionDefinitionProvider)),
+            provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMMaintenanceManagementMenuProvider)),
+            provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMMaintenanceManagementSearchCommandProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-maintenance-management-client-failure-register-status.provider-CLBaQy_e.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
+            provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-maintenance-management-client-work-order-status.provider-DvBk5kAW.mjs').then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
+            provideCommandMiddleware([
+                {
+                    target: 'AssessmentManagement.AssessmentCase:Fill',
+                    middleware: workOrderChecklistPostSubmitMiddleware,
+                },
+                {
+                    target: 'AssessmentManagement.AssessmentCase:Fill',
+                    middleware: workOrderChecklistFillMiddleware,
+                },
+            ]),
+            provideCommandSetups([
+                {
+                    key: 'Entity:List',
+                    command: () => import('./acorex-platform-module-maintenance-management-client-work-order-list-command-Bh_6PS5w.mjs').then((c) => c.WorkOrderListCommand),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkOrder.StartFlow,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-start-work-order-flow.command-B06a962Y.mjs').then((c) => c.StartWorkOrderFlowCommand),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ResolveWorkOrder,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-resolve-work-order.activity-q5WM7Sv5.mjs').then((c) => c.ResolveWorkOrderActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ResolvePersonUserId,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-resolve-person-user-id.activity-nwXAJHkd.mjs').then((c) => c.ResolvePersonUserIdActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.CreateOrGetWorkReportDraft,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-create-or-get-work-report-draft.activity-xxvOfIxf.mjs').then((c) => c.CreateOrGetWorkReportDraftActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkOrderInProgress,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-update-work-order-in-progress.activity-CzkCCl1L.mjs').then((c) => c.UpdateWorkOrderInProgressActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ValidateWorkOrderCompletion,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-validate-work-order-completion.activity-RA2zaQHH.mjs').then((c) => c.ValidateWorkOrderCompletionActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkReportOnCompletion,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-update-work-report-on-completion.activity-_B0SUFtQ.mjs').then((c) => c.UpdateWorkReportOnCompletionActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.RecordWorkReportAssessment,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-record-work-report-assessment.activity-CxRfaf0G.mjs').then((c) => c.RecordWorkReportAssessmentActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkOrderCompleted,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-update-work-order-completed.activity-Di4R6LQl.mjs').then((c) => c.UpdateWorkOrderCompletedActivity),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkReport.FillCompletion,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-fill-work-report-completion.command-Capowl1e.mjs').then((c) => c.FillWorkReportCompletionCommand),
+                },
+                {
+                    key: AXMMaintenanceManagementCommandKeys.WorkReport.OpenFromWorkOrder,
+                    command: () => import('./acorex-platform-module-maintenance-management-client-open-work-report-from-work-order.command-B0O4fWPt.mjs').then((c) => c.OpenWorkReportFromWorkOrderCommand),
+                },
+            ]),
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: assetCreateMaintenanceOfferMiddleware,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: failureRegisterCreateWorkOrderMiddleware,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: maintenancePlanCreateWorkOrderMiddleware,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                useValue: workOrderSourceTypeMiddleware,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: MaintenanceManagementManifest,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMMaintenanceManagementCatalogScopeDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMMaintenanceManagementWorkOrderExpressionEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMWorkReportWidgetProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMWorkOrderWorkflowColumnWidgetProvider,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMMaintenanceManagementPermissionDefinitionProvider)),
+                        provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMMaintenanceManagementMenuProvider)),
+                        provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then((m) => m.AXMMaintenanceManagementSearchCommandProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-maintenance-management-client-failure-register-status.provider-CLBaQy_e.mjs').then((m) => m.AXMMaintenanceManagementFailureRegisterStatusProvider)),
+                        provideLazyProvider(AXP_STATUS_PROVIDERS, () => import('./acorex-platform-module-maintenance-management-client-work-order-status.provider-DvBk5kAW.mjs').then((m) => m.AXMMaintenanceManagementWorkOrderStatusProvider)),
+                        provideCommandMiddleware([
+                            {
+                                target: 'AssessmentManagement.AssessmentCase:Fill',
+                                middleware: workOrderChecklistPostSubmitMiddleware,
+                            },
+                            {
+                                target: 'AssessmentManagement.AssessmentCase:Fill',
+                                middleware: workOrderChecklistFillMiddleware,
+                            },
+                        ]),
+                        provideCommandSetups([
+                            {
+                                key: 'Entity:List',
+                                command: () => import('./acorex-platform-module-maintenance-management-client-work-order-list-command-Bh_6PS5w.mjs').then((c) => c.WorkOrderListCommand),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkOrder.StartFlow,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-start-work-order-flow.command-B06a962Y.mjs').then((c) => c.StartWorkOrderFlowCommand),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ResolveWorkOrder,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-resolve-work-order.activity-q5WM7Sv5.mjs').then((c) => c.ResolveWorkOrderActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ResolvePersonUserId,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-resolve-person-user-id.activity-nwXAJHkd.mjs').then((c) => c.ResolvePersonUserIdActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.CreateOrGetWorkReportDraft,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-create-or-get-work-report-draft.activity-xxvOfIxf.mjs').then((c) => c.CreateOrGetWorkReportDraftActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkOrderInProgress,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-update-work-order-in-progress.activity-CzkCCl1L.mjs').then((c) => c.UpdateWorkOrderInProgressActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.ValidateWorkOrderCompletion,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-validate-work-order-completion.activity-RA2zaQHH.mjs').then((c) => c.ValidateWorkOrderCompletionActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkReportOnCompletion,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-update-work-report-on-completion.activity-_B0SUFtQ.mjs').then((c) => c.UpdateWorkReportOnCompletionActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.RecordWorkReportAssessment,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-record-work-report-assessment.activity-CxRfaf0G.mjs').then((c) => c.RecordWorkReportAssessmentActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkflowActivity.UpdateWorkOrderCompleted,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-update-work-order-completed.activity-Di4R6LQl.mjs').then((c) => c.UpdateWorkOrderCompletedActivity),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkReport.FillCompletion,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-fill-work-report-completion.command-Capowl1e.mjs').then((c) => c.FillWorkReportCompletionCommand),
+                            },
+                            {
+                                key: AXMMaintenanceManagementCommandKeys.WorkReport.OpenFromWorkOrder,
+                                command: () => import('./acorex-platform-module-maintenance-management-client-open-work-report-from-work-order.command-B0O4fWPt.mjs').then((c) => c.OpenWorkReportFromWorkOrderCommand),
+                            },
+                        ]),
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: assetCreateMaintenanceOfferMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: failureRegisterCreateWorkOrderMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: maintenancePlanCreateWorkOrderMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            useValue: workOrderSourceTypeMiddleware,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Menu Provider   ----
+const PLAN_EQUIPMENT_MENU_KEY = 'Configuration:Menu:PlantEquipment';
+// const PLAN_EQUIPMENT_ASSET_MAINTENANCE_DIVIDER_KEY = `${PLAN_EQUIPMENT_MENU_KEY}:divider-assets-maintenance`;
+/**
+ * Maintenance Management Menu Provider.
+ * Provides menu items for the Maintenance Management module with permission and feature checks.
+ */
+class AXMMaintenanceManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const keys = AXPAssetsMaintenancePermissionKeys;
+        // const mainMaintenanceSectionGroup = context.find(
+        //   AXMMaintenanceManagementMenuKeys.MainPlanEquipmentMaintenanceSectionGroup,
+        // );
+        // if (!mainMaintenanceSectionGroup.exists) {
+        //   context.find(AXPCommonMenuKeys.PlantEquipment).addItems([
+        //     {
+        //       name: AXMMaintenanceManagementMenuKeys.MainPlanEquipmentMaintenanceSectionGroup,
+        //       priority: 11,
+        //       text: '@general:menus.maintenance.title',
+        //       type: 'group',
+        //     },
+        //   ]);
+        // }
+        context.find(AXPCommonMenuKeys.PlantEquipment).addItems([
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureRegisters,
+                text: RootConfig.entities.failureRegister.titlePlural,
+                icon: RootConfig.entities.failureRegister.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureRegister.name),
+                priority: 12,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+        ]);
+        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,
+                },
+            ]);
+        }
+        // const maintenanceSectionGroup = context.find(AXMMaintenanceManagementMenuKeys.PlanEquipmentMaintenanceSectionGroup);
+        // if (!maintenanceSectionGroup.exists) {
+        //   context.find(PLAN_EQUIPMENT_MENU_KEY).addItems([
+        //     {
+        //       name: AXMMaintenanceManagementMenuKeys.PlanEquipmentMaintenanceSectionGroup,
+        //       priority: 11,
+        //       text: '@general:menus.maintenance.title',
+        //       type: 'group',
+        //     },
+        //   ]);
+        // }
+        context.find(PLAN_EQUIPMENT_MENU_KEY).addItems([
+            {
+                name: AXMMaintenanceManagementMenuKeys.MaintenanceTypes,
+                text: RootConfig.entities.maintenanceType.titlePlural,
+                icon: RootConfig.entities.maintenanceType.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.maintenanceType.name),
+                priority: 12,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.ActivityTypes,
+                text: RootConfig.entities.activityType.titlePlural,
+                icon: RootConfig.entities.activityType.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.activityType.name),
+                priority: 13,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.Failures,
+                text: '@maintenance-management:module.menus.failures.title',
+                type: 'group',
+                priority: 14,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureCauses,
+                text: RootConfig.entities.failureCause.titlePlural,
+                icon: RootConfig.entities.failureCause.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureCause.name),
+                priority: 15,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureMechanisms,
+                text: RootConfig.entities.failureMechanism.titlePlural,
+                icon: RootConfig.entities.failureMechanism.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureMechanism.name),
+                priority: 16,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureDetections,
+                text: RootConfig.entities.failureDetection.titlePlural,
+                icon: RootConfig.entities.failureDetection.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureDetection.name),
+                priority: 17,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureEffects,
+                text: RootConfig.entities.failureEffect.titlePlural,
+                icon: RootConfig.entities.failureEffect.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureEffect.name),
+                priority: 18,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureSeverities,
+                text: RootConfig.entities.failureSeverity.titlePlural,
+                icon: RootConfig.entities.failureSeverity.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureSeverity.name),
+                priority: 19,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureTypes,
+                text: RootConfig.entities.failureType.titlePlural,
+                icon: RootConfig.entities.failureType.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureType.name),
+                priority: 20,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            {
+                name: AXMMaintenanceManagementMenuKeys.FailureModes,
+                text: RootConfig.entities.failureMode.titlePlural,
+                icon: RootConfig.entities.failureMode.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.failureMode.name),
+                priority: 21,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainMaintenance],
+                },
+            },
+            // {
+            //   name: AXMMaintenanceManagementMenuKeys.MaintenanceTemplateActivityTypes,
+            //   text: RootConfig.entities.maintenanceTemplateActivityType.titlePlural,
+            //   icon: RootConfig.entities.maintenanceTemplateActivityType.icon,
+            //   path: this.entityService.createPath(module.name, RootConfig.entities.maintenanceTemplateActivityType.name),
+            //   priority: 4,
+            //   policy: {
+            //     features: [module.name],
+            //     permissions: [keys.MaintenanceTemplateActivityType.View],
+            //   },
+            // },
+            // {
+            //   name: AXMMaintenanceManagementMenuKeys.MaintenanceTemplateResources,
+            //   text: RootConfig.entities.maintenanceTemplateResource.titlePlural,
+            //   icon: RootConfig.entities.maintenanceTemplateResource.icon,
+            //   path: this.entityService.createPath(module.name, RootConfig.entities.maintenanceTemplateResource.name),
+            //   priority: 5,
+            //   policy: {
+            //     features: [module.name],
+            //     permissions: [keys.MaintenanceTemplateResource.View],
+            //   },
+            // },
+            // {
+            //   name: AXMMaintenanceManagementMenuKeys.MaintenanceTemplateFailureModes,
+            //   text: RootConfig.entities.maintenanceTemplateFailureMode.titlePlural,
+            //   icon: RootConfig.entities.maintenanceTemplateFailureMode.icon,
+            //   path: this.entityService.createPath(module.name, RootConfig.entities.maintenanceTemplateFailureMode.name),
+            //   priority: 6,
+            //   policy: {
+            //     features: [module.name],
+            //     permissions: [keys.MaintenanceTemplateFailureMode.View],
+            //   },
+            // },
+        ]);
+    }
+}
+//#endregion
+
+var menu_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMMaintenanceManagementMenuProvider: AXMMaintenanceManagementMenuProvider
+});
+
+//#endregion
+//#region ----- Permission Definition Provider -----
+/**
+ * Registers maintenance capabilities into the shared Assets & Maintenance group.
+ */
+class AXMMaintenanceManagementPermissionDefinitionProvider {
+    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.Maintenance, `${G}.assets-maintenance-maintenance.title`, `${G}.assets-maintenance-maintenance.description`, { parent: groups.AssetsMaintenance.Root, order: 20 })
+            .addPermission(keys.MaintainMaintenance, `${P}.maintain-maintenance.title`, `${P}.maintain-maintenance.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMaintenanceManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMMaintenanceManagementPermissionDefinitionProvider: AXMMaintenanceManagementPermissionDefinitionProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Search Command Provider   ----
+class AXMMaintenanceManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                id: 'create-maintenance-type',
+                group: 'command',
+                title: RootConfig.entities.maintenanceType.title,
+                icon: RootConfig.entities.maintenanceType.icon,
+                description: RootConfig.entities.maintenanceType.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.maintenanceType.name}`, {
+                        name: RootConfig.entities.maintenanceType.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.maintenanceType.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-maintenance-template',
+                group: 'command',
+                title: RootConfig.entities.maintenanceTemplate.title,
+                icon: RootConfig.entities.maintenanceTemplate.icon,
+                description: RootConfig.entities.maintenanceTemplate.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.maintenanceTemplate.name}`, {
+                        name: RootConfig.entities.maintenanceTemplate.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.maintenanceTemplate.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-maintenance-plan',
+                group: 'command',
+                title: RootConfig.entities.maintenancePlan.title,
+                icon: RootConfig.entities.maintenancePlan.icon,
+                description: RootConfig.entities.maintenancePlan.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.maintenancePlan.name}`, {
+                        name: RootConfig.entities.maintenancePlan.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.maintenancePlan.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-work-report',
+                group: 'command',
+                title: RootConfig.entities.workReport.title,
+                icon: RootConfig.entities.workReport.icon,
+                description: RootConfig.entities.workReport.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.workReport.name}`, {
+                        name: RootConfig.entities.workReport.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.workReport.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-activity-type-resource',
+                group: 'command',
+                title: RootConfig.entities.activityTypeResource.title,
+                icon: RootConfig.entities.activityTypeResource.icon,
+                description: RootConfig.entities.activityTypeResource.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.activityTypeResource.name}`, {
+                        name: RootConfig.entities.activityTypeResource.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.activityTypeResource.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-failure-mode',
+                group: 'command',
+                title: RootConfig.entities.failureMode.title,
+                icon: RootConfig.entities.failureMode.icon,
+                description: RootConfig.entities.failureMode.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.failureMode.name}`, {
+                        name: RootConfig.entities.failureMode.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.failureMode.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-failure-cause',
+                group: 'command',
+                title: RootConfig.entities.failureCause.title,
+                icon: RootConfig.entities.failureCause.icon,
+                description: RootConfig.entities.failureCause.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.failureCause.name}`, { name: RootConfig.entities.failureCause.name, module: RootConfig.module.name, title: RootConfig.entities.failureCause.title }),
+                },
+            },
+            {
+                id: 'create-failure-mechanism',
+                group: 'command',
+                title: RootConfig.entities.failureMechanism.title,
+                icon: RootConfig.entities.failureMechanism.icon,
+                description: RootConfig.entities.failureMechanism.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.failureMechanism.name}`, {
+                        name: RootConfig.entities.failureMechanism.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.failureMechanism.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-failure-detection',
+                group: 'command',
+                title: RootConfig.entities.failureDetection.title,
+                icon: RootConfig.entities.failureDetection.icon,
+                description: RootConfig.entities.failureDetection.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.failureDetection.name}`, {
+                        name: RootConfig.entities.failureDetection.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.failureDetection.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-failure-type',
+                group: 'command',
+                title: RootConfig.entities.failureType.title,
+                icon: RootConfig.entities.failureType.icon,
+                description: RootConfig.entities.failureType.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.failureType.name}`, {
+                        name: RootConfig.entities.failureType.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.failureType.title,
+                    }),
+                },
+            },
+        ];
+    }
+}
+//#endregion
+
+var searchCommand_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMMaintenanceManagementSearchCommandProvider: AXMMaintenanceManagementSearchCommandProvider
+});
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Expression helpers ----
+const WFM_EXPR_ASSIGNED_USER = 'context.eval("variables.assignedUserId")';
+const WFM_EXPR_WORK_ORDER_ID = 'context.eval("inputs.workOrderId")';
+const WFM_EXPR_ASSET_ID = 'context.eval("inputs.assetId")';
+const WFM_EXPR_MAINTENANCE_TYPE_ID = 'context.eval("inputs.maintenanceTypeId")';
+const wfmExpr = (expression) => `{{ ${expression} }}`;
+const workOrderTaskContext = {
+    workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+    workOrderNo: '{{ inputs.workOrderNo }}',
+    assetId: wfmExpr(WFM_EXPR_ASSET_ID),
+    assetDisplayName: '{{ inputs.assetDisplayName }}',
+    maintenanceTypeId: '{{ inputs.maintenanceTypeId }}',
+    maintenanceTypeName: '{{ inputs.maintenanceTypeName }}',
+    maintenancePlanId: '{{ inputs.maintenancePlanId }}',
+    failureRegisterId: '{{ inputs.failureRegisterId }}',
+    sourceType: '{{ inputs.sourceType }}',
+    dueDate: '{{ inputs.dueDate }}',
+    entityType: 'MaintenanceManagement.WorkOrder',
+};
+const startWorkAction = {
+    name: 'start-work',
+    title: 'Start work',
+    icon: 'fa-light fa-play',
+    color: 'primary',
+    command: { name: 'start-work' },
+};
+const completeWorkAction = {
+    name: 'complete-work',
+    title: 'Complete work',
+    icon: 'fa-light fa-check',
+    color: 'success',
+    command: { name: 'complete-work' },
+};
+//#endregion
+/**
+ * Executes an existing work order: assignee task board → start work → in progress → complete work → completed.
+ * Approval/sign-off is intentionally excluded (separate workflow).
+ */
+function createWorkOrderExecutionWorkflowDefinition(config) {
+    const { name, title, description, startTaskTitle, inProgressTaskTitle } = config;
+    const activityKeys = AXMMaintenanceManagementCommandKeys.WorkflowActivity;
+    const assetActivityKey = AXMAssetManagementCommandKeys.WorkflowActivity.RecalculateOperationalStatus;
+    return {
+        schemaVersion: 'acorex-platform-workflow/v1',
+        name,
+        title,
+        description,
+        variables: [
+            {
+                name: 'assignedUserId',
+                title: 'Assigned user',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assignedPersonId',
+                title: 'Assigned person',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assetStatusTarget',
+                title: 'Asset status target',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'workStartedAt',
+                title: 'Work started at',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'workCompletedAt',
+                title: 'Work completed at',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+        ],
+        inputs: [
+            {
+                name: 'workOrderId',
+                title: 'Work order ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'workOrderNo',
+                title: 'Work order number',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assetId',
+                title: 'Asset ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assetDisplayName',
+                title: 'Asset display name',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assignedToId',
+                title: 'Assigned person ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'assignedToDisplayName',
+                title: 'Assigned person display name',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'maintenanceTypeId',
+                title: 'Maintenance type ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'maintenanceTypeName',
+                title: 'Maintenance type name',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'maintenancePlanId',
+                title: 'Maintenance plan ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'failureRegisterId',
+                title: 'Failure register ID',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'sourceType',
+                title: 'Source type',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+            {
+                name: 'dueDate',
+                title: 'Due date',
+                dataType: 'string',
+                interface: { type: 'text-editor', options: {} },
+            },
+        ],
+        outputs: [],
+        extensions: {},
+        graph: {
+            startActivityId: 'resolveWorkOrder',
+            activities: [
+                {
+                    id: 'resolveWorkOrder',
+                    name: activityKeys.ResolveWorkOrder,
+                    title: 'Resolve work order',
+                    inputs: {
+                        workOrderId: '{{ inputs.workOrderId }}',
+                        assignedToId: '{{ inputs.assignedToId }}',
+                    },
+                    outputToVariables: {
+                        assignedPersonId: 'assignedToId',
+                    },
+                },
+                {
+                    id: 'resolveAssignedUser',
+                    name: activityKeys.ResolvePersonUserId,
+                    title: 'Resolve assigned user',
+                    inputs: {
+                        personId: '{{ variables.assignedPersonId || inputs.assignedToId }}',
+                    },
+                    outputToVariables: { assignedUserId: 'userId' },
+                },
+                {
+                    id: 'showAssignedUserRequiredToast',
+                    name: 'workflow-activity:show-toast',
+                    title: 'Assigned user required',
+                    inputs: {
+                        message: 'Assigned user is required before starting work order execution.',
+                        type: 'warning',
+                    },
+                },
+                {
+                    id: 'createWorkOrderTask',
+                    name: 'workflow-activity:human-task',
+                    title: startTaskTitle,
+                    inputs: {
+                        title: 'Work order: {{ inputs.workOrderNo }}',
+                        description: 'Start the assigned maintenance work when you are ready.',
+                        assignedUserIds: wfmExpr(WFM_EXPR_ASSIGNED_USER),
+                        dueDate: '{{ inputs.dueDate }}',
+                        context: workOrderTaskContext,
+                        actions: { suffix: [startWorkAction] },
+                    },
+                },
+                {
+                    id: 'updateWorkOrderInProgress',
+                    name: activityKeys.UpdateWorkOrderInProgress,
+                    title: 'Work order — in progress',
+                    inputs: {
+                        workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+                    },
+                    outputToVariables: { workStartedAt: 'startedAt' },
+                },
+                {
+                    id: 'recalculateAssetStatusOnStart',
+                    name: assetActivityKey,
+                    title: 'Recalculate asset status (work started)',
+                    inputs: {
+                        assetId: wfmExpr(WFM_EXPR_ASSET_ID),
+                        trigger: 'work-started',
+                        workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+                        maintenanceTypeId: wfmExpr(WFM_EXPR_MAINTENANCE_TYPE_ID),
+                    },
+                    outputToVariables: { assetStatusTarget: 'statusId' },
+                },
+                {
+                    id: 'workInProgressTask',
+                    name: 'workflow-activity:human-task',
+                    title: inProgressTaskTitle,
+                    inputs: {
+                        title: 'Work order: {{ inputs.workOrderNo }}',
+                        description: 'Perform the maintenance work, then mark it complete.',
+                        assignedUserIds: wfmExpr(WFM_EXPR_ASSIGNED_USER),
+                        dueDate: '{{ inputs.dueDate }}',
+                        context: workOrderTaskContext,
+                        actions: { suffix: [completeWorkAction] },
+                    },
+                },
+                {
+                    id: 'showWorkCompletionValidationFailedToast',
+                    name: 'workflow-activity:show-toast',
+                    title: 'Work completion validation failed',
+                    inputs: {
+                        message: 'Work order cannot be completed yet. Ensure work is in progress and requirements are met.',
+                        type: 'warning',
+                    },
+                },
+                {
+                    id: 'validateWorkCompletion',
+                    name: activityKeys.ValidateWorkOrderCompletion,
+                    title: 'Validate work completion',
+                    inputs: {
+                        workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+                    },
+                },
+                {
+                    id: 'updateWorkOrderCompleted',
+                    name: activityKeys.UpdateWorkOrderCompleted,
+                    title: 'Work order — completed',
+                    inputs: {
+                        workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+                    },
+                    outputToVariables: { workCompletedAt: 'completedAt' },
+                },
+                {
+                    id: 'recalculateAssetStatusOnComplete',
+                    name: assetActivityKey,
+                    title: 'Recalculate asset status (work completed)',
+                    inputs: {
+                        assetId: wfmExpr(WFM_EXPR_ASSET_ID),
+                        trigger: 'work-completed',
+                        workOrderId: wfmExpr(WFM_EXPR_WORK_ORDER_ID),
+                        maintenanceTypeId: wfmExpr(WFM_EXPR_MAINTENANCE_TYPE_ID),
+                    },
+                },
+            ],
+            connections: [
+                { source: { activtyName: 'resolveWorkOrder', port: 'Done' }, target: { activtyName: 'resolveAssignedUser' } },
+                {
+                    source: { activtyName: 'resolveWorkOrder', port: 'Blocked' },
+                    target: { activtyName: 'showAssignedUserRequiredToast' },
+                },
+                {
+                    source: { activtyName: 'resolveWorkOrder', port: 'NotFound' },
+                    target: { activtyName: 'showAssignedUserRequiredToast' },
+                },
+                {
+                    source: { activtyName: 'resolveAssignedUser', port: 'Done' },
+                    target: { activtyName: 'createWorkOrderTask' },
+                },
+                {
+                    source: { activtyName: 'createWorkOrderTask', port: 'start-work' },
+                    target: { activtyName: 'updateWorkOrderInProgress' },
+                },
+                {
+                    source: { activtyName: 'updateWorkOrderInProgress', port: 'Done' },
+                    target: { activtyName: 'recalculateAssetStatusOnStart' },
+                },
+                {
+                    source: { activtyName: 'recalculateAssetStatusOnStart', port: 'Done' },
+                    target: { activtyName: 'workInProgressTask' },
+                },
+                {
+                    source: { activtyName: 'workInProgressTask', port: 'complete-work' },
+                    target: { activtyName: 'validateWorkCompletion' },
+                },
+                {
+                    source: { activtyName: 'validateWorkCompletion', port: 'Done' },
+                    target: { activtyName: 'updateWorkOrderCompleted' },
+                },
+                {
+                    source: { activtyName: 'validateWorkCompletion', port: 'Failed' },
+                    target: { activtyName: 'showWorkCompletionValidationFailedToast' },
+                },
+                {
+                    source: { activtyName: 'showWorkCompletionValidationFailedToast', port: 'Done' },
+                    target: { activtyName: 'workInProgressTask' },
+                },
+                {
+                    source: { activtyName: 'updateWorkOrderCompleted', port: 'Done' },
+                    target: { activtyName: 'recalculateAssetStatusOnComplete' },
+                },
+            ],
+        },
+    };
+}
+const workOrderExecutionWorkflowName = 'work-order-execution';
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+const M = createMultiLanguageString;
+//#endregion
+//#region ---- Definition export ----
+/** Published workflow graph for seeding `WorkflowManagement.WorkflowDefinition`. */
+const workOrderExecutionWorkflowDefinition = createWorkOrderExecutionWorkflowDefinition({
+    name: workOrderExecutionWorkflowName,
+    title: M('Work order execution', 'اجرای دستور کار'),
+    description: M('Assignee task board, start work, asset status recalculation, complete work. Approval is a separate workflow.', 'کارتابل مسئول، شروع کار، محاسبه وضعیت دارایی، تکمیل کار. تأیید در گردش کار جداگانه انجام می‌شود.'),
+    startTaskTitle: 'Start work — work order',
+    inProgressTaskTitle: 'Complete work — work order',
+});
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXM_WORK_ORDER_WORKFLOW_DEBUG_NAMESPACE as A, AXMMaintenanceManagementMenuProvider as a, AXMMaintenanceManagementModule as b, AXMMaintenanceManagementPermissionDefinitionProvider as c, AXMMaintenanceManagementSearchCommandProvider as d, createWorkOrderExecutionWorkflowDefinition as e, workOrderExecutionWorkflowName as f, queryWorkflowTemplatesForAsset as q, resolveDisplayLabel as r, workOrderExecutionWorkflowDefinition as w };
+//# sourceMappingURL=acorex-platform-module-maintenance-management-client-acorex-platform-module-maintenance-management-client-BiQlJxPX.mjs.map