@acorex/modules 21.0.0-next.76 → 21.0.0-next.79

package/fesm2022/acorex-modules-health-core.mjs

@@ -1,195 +1,13 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, NgModule } from '@angular/core';
-import { AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
-import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { AXPEntityCommandScope, AXPStatusProvider, systemStatusToDefinition, AXPSystemStatusType, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { NgModule, inject } from '@angular/core';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
+import { AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
+import { AXP_MENU_PROVIDER } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPRuntimeModule, provideCommandSetups } from '@acorex/platform/runtime';
-import { AXPWidgetsList, createAllQueryView, entityMasterCrudActions, entityMasterRecordActions } from '@acorex/platform/contracts';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
-import { AXTranslationService, resolveMultiLanguageString } from '@acorex/core/translation';
-import { get } from 'lodash-es';
 import { AXPCommonMenuKeys } from '@acorex/modules/common';
-
-/** Health catalog scope for questionnaires, question bank items, and workflow definitions. */
-const HEALTH_CATALOG_SCOPE = 'health-core.health';
-
-//#endregion
-//#region ---- Constants ----
-const QUESTIONNAIRE = 'AssessmentManagement.Questionnaire';
-const QUESTION_BANK_ITEM = 'AssessmentManagement.QuestionBankItem';
-const WORKFLOW_DEFINITION = 'WorkflowManagement.WorkflowDefinition';
-const HEALTH_CATALOG_TARGETS = [QUESTIONNAIRE, QUESTION_BANK_ITEM, WORKFLOW_DEFINITION];
-//#endregion
-//#region ---- Provider ----
-class AXMHealthCoreCatalogScopeDefinitionProvider {
-    async items() {
-        return [
-            {
-                name: HEALTH_CATALOG_SCOPE,
-                title: '@health-core:catalog-scopes.health.title',
-                description: '@health-core:catalog-scopes.health.description',
-                targets: [...HEALTH_CATALOG_TARGETS],
-                icon: 'fa-light fa-heart-pulse',
-                cssClass: 'ax-danger-lighter',
-                order: 11,
-            },
-        ];
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreCatalogScopeDefinitionProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreCatalogScopeDefinitionProvider, decorators: [{
-            type: Injectable
-        }] });
-
-const AXMHealthCoreCommandKeys = {
-    HealthEvent: {
-        StartFlow: 'HealthCore.HealthEvent:StartFlow',
-    },
-};
-
-//#region ---- Datasource keys ----
-/** Health Core datasource registry names. */
-const AXMHealthCoreDataSourceKeys = {
-    MedicationFormOptions: 'medication-form-options',
-    HealthRiskLevelOptions: 'health-risk-level-options',
-    AlcoholConsumptionOptions: 'alcohol-consumption-options',
-    SmokingStatusOptions: 'smoking-status-options',
-    AllergySeverityOptions: 'allergy-severity-options',
-    ChronicConditionStatusOptions: 'chronic-condition-status-options',
-    InjuryMechanismOptions: 'injury-mechanism-options',
-    WorkCapacityOptions: 'work-capacity-options',
-    PainRateOptions: 'pain-rate-options',
-};
-//#endregion
-
-const AXMHealthCoreMenuKeys = {
-    Root: 'health-core',
-    BloodTypes: 'health-core.blood-types',
-    BodyParts: 'health-core.body-parts',
-    DisabilityStatuses: 'health-core.disability-statuses',
-    InjuryTypes: 'health-core.injury-types',
-    VaccinationTypes: 'health-core.vaccination-types',
-    HealthConditionTypes: 'health-core.health-condition-types',
-    HealthRestrictions: 'health-core.health-restrictions',
-    HealthRecordTypes: 'health-core.health-record-types',
-    HealthEvents: 'health-core.health-events',
-    HealthProfiles: 'health-core.health-profiles',
-    HealthConditions: 'health-core.health-conditions',
-};
-
-const AXMHealthCorePermissionKeys = {
-    HealthCore: {
-        BloodType: { Management: 'HealthCore:Permission:BloodType.Management' },
-        BodyPart: { Management: 'HealthCore:Permission:BodyPart.Management' },
-        DisabilityStatus: { Management: 'HealthCore:Permission:DisabilityStatus.Management' },
-        InjuryType: { Management: 'HealthCore:Permission:InjuryType.Management' },
-        VaccinationType: { Management: 'HealthCore:Permission:VaccinationType.Management' },
-        HealthConditionType: { Management: 'HealthCore:Permission:HealthConditionType.Management' },
-        HealthRestriction: { Management: 'HealthCore:Permission:HealthRestriction.Management' },
-        HealthRecordType: { Management: 'HealthCore:Permission:HealthRecordType.Management' },
-        HealthProfile: {
-            ViewOwn: 'HealthCore:Permission:HealthProfile.ViewOwn',
-            EditOwn: 'HealthCore:Permission:HealthProfile.EditOwn',
-            View: 'HealthCore:Permission:HealthProfile.View',
-            Manage: 'HealthCore:Permission:HealthProfile.Manage',
-        },
-        HealthCondition: {
-            ViewOwn: 'HealthCore:Permission:HealthCondition.ViewOwn',
-            EditOwn: 'HealthCore:Permission:HealthCondition.EditOwn',
-            View: 'HealthCore:Permission:HealthCondition.View',
-            Manage: 'HealthCore:Permission:HealthCondition.Manage',
-        },
-        HealthEvent: {
-            ViewOwn: 'HealthCore:Permission:HealthEvent.ViewOwn',
-            EditOwn: 'HealthCore:Permission:HealthEvent.EditOwn',
-            View: 'HealthCore:Permission:HealthEvent.View',
-            Manage: 'HealthCore:Permission:HealthEvent.Manage',
-        },
-    },
-};
-
-//#region ---- Subject form layout helpers ----
-/** Subject lookup field omitted from create/update when injected from parent context. */
-const HEALTH_SUBJECT_PROPERTY_NAMES = ['subject.id'];
-/** Omits subject lookup from master create/update layouts (subject is injected from context). */
-function omitHealthSubjectFromEditLayouts(layouts) {
-    return layouts.filter((layout) => !HEALTH_SUBJECT_PROPERTY_NAMES.includes(layout.name));
-}
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Subject filter helpers ----
-/** Person subject type for health records shared between My Profile and employee detail. */
-const HEALTH_PERSON_SUBJECT_TYPE = 'PersonCore.Person';
-/** Filters child health records by polymorphic subject on a parent entity detail context. */
-function healthSubjectReferenceConditions(subjectType) {
-    return [
-        {
-            name: 'subject.type',
-            operator: { type: 'equal' },
-            value: subjectType,
-        },
-        {
-            name: 'subject.id',
-            operator: { type: 'equal' },
-            value: '{{context.eval("id")}}',
-        },
-    ];
-}
-/**
- * Filters health records for an employee's linked person (`personId` on employee context).
- * Use for HealthProfile (and other person-scoped records) on employee detail so data matches My Profile.
- */
-function healthPersonSubjectReferenceConditions(personIdExpression = '{{context.eval("personId")}}') {
-    return [
-        {
-            name: 'subject.type',
-            operator: { type: 'equal' },
-            value: HEALTH_PERSON_SUBJECT_TYPE,
-        },
-        {
-            name: 'subject.id',
-            operator: { type: 'equal' },
-            value: personIdExpression,
-        },
-    ];
-}
-//#endregion
-//#region ---- Subject lookup property ----
-/** Single polymorphic subject lookup (assessment-case `subjectRef.id` pattern). */
-function createHealthSubjectLookupProperty(groupId, options = {}) {
-    const readonly = options.readonly ?? false;
-    return {
-        name: 'subject.id',
-        title: '@health-core:terms.subject.title',
-        groupId,
-        options: readonly
-            ? { sort: { enabled: false }, filter: { advance: { enabled: false }, inline: { enabled: false } } }
-            : undefined,
-        schema: {
-            dataType: 'string',
-            readonly,
-            interface: {
-                type: AXPWidgetsList.Editors.LookupBox,
-                options: {
-                    readonly,
-                    entity: "{{ context.eval('subject.type') }}",
-                    valueField: 'id',
-                    expose: [
-                        { source: 'id', target: 'subject.id' },
-                        { source: 'title', target: 'subject.title' },
-                    ],
-                },
-            },
-        },
-        validations: [{ rule: 'required' }],
-    };
-}
-//#endregion
+import { AXTranslationService } from '@acorex/core/translation';
 
 const config = {
     i18n: 'health-core',
@@ -203,6 +21,12 @@ const RootConfig = {
         icon: 'fa-light fa-heart-pulse',
     },
     entities: {
+        allergyType: {
+            name: 'AllergyType',
+            title: `@${config.i18n}:allergy-types.entities.allergy-type.title`,
+            titlePlural: `@${config.i18n}:allergy-types.entities.allergy-type.plural`,
+            icon: 'fa-light fa-allergies',
+        },
         bloodType: {
             name: 'BloodType',
             title: `@${config.i18n}:blood-types.entities.blood-type.title`,
@@ -215,6 +39,12 @@ const RootConfig = {
             titlePlural: `@${config.i18n}:body-parts.entities.body-part.plural`,
             icon: 'fa-light fa-person',
         },
+        chronicConditionType: {
+            name: 'ChronicConditionType',
+            title: `@${config.i18n}:chronic-condition-types.entities.chronic-condition-type.title`,
+            titlePlural: `@${config.i18n}:chronic-condition-types.entities.chronic-condition-type.plural`,
+            icon: 'fa-light fa-file-medical',
+        },
         disabilityStatus: {
             name: 'DisabilityStatus',
             title: `@${config.i18n}:disability-statuses.entities.disability-status.title`,
@@ -233,48 +63,9 @@ const RootConfig = {
             titlePlural: `@${config.i18n}:vaccination-types.entities.vaccination-type.plural`,
             icon: 'fa-light fa-syringe',
         },
-        healthConditionType: {
-            name: 'HealthConditionType',
-            title: `@${config.i18n}:health-condition-types.entities.health-condition-type.title`,
-            titlePlural: `@${config.i18n}:health-condition-types.entities.health-condition-type.plural`,
-            icon: 'fa-light fa-file-medical',
-        },
-        healthRestriction: {
-            name: 'HealthRestriction',
-            title: `@${config.i18n}:health-restrictions.entities.health-restriction.title`,
-            titlePlural: `@${config.i18n}:health-restrictions.entities.health-restriction.plural`,
-            icon: 'fa-light fa-ban',
-        },
-        healthRecordType: {
-            name: 'HealthRecordType',
-            title: `@${config.i18n}:health-record-types.entities.health-record-type.title`,
-            titlePlural: `@${config.i18n}:health-record-types.entities.health-record-type.plural`,
-            icon: 'fa-light fa-notes-medical',
-        },
-        healthEvent: {
-            name: 'HealthEvent',
-            title: `@${config.i18n}:health-events.entities.health-event.title`,
-            titlePlural: `@${config.i18n}:health-events.entities.health-event.plural`,
-            icon: 'fa-light fa-file-medical',
-        },
-        healthProfile: {
-            name: 'HealthProfile',
-            title: `@${config.i18n}:health-profiles.entities.health-profile.title`,
-            titlePlural: `@${config.i18n}:health-profiles.entities.health-profile.plural`,
-            icon: 'fa-light fa-heart-pulse',
-        },
-        healthCondition: {
-            name: 'HealthCondition',
-            title: `@${config.i18n}:health-conditions.entities.health-condition.title`,
-            titlePlural: `@${config.i18n}:health-conditions.entities.health-condition.plural`,
-            icon: 'fa-light fa-file-medical',
-        },
     },
 };
 
-//#region ---- Contracts barrel ----
-//#endregion
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Manifest Definition   ----
@@ -291,6 +82,16 @@ const HealthCoreManifest = {
 };
 //#endregion
 
+//#region ---- Datasource keys ----
+/** Health Core datasource registry names. */
+const AXMHealthCoreDataSourceKeys = {
+    MedicationFormOptions: 'medication-form-options',
+    HealthRiskLevelOptions: 'health-risk-level-options',
+    AlcoholConsumptionOptions: 'alcohol-consumption-options',
+    SmokingStatusOptions: 'smoking-status-options',
+};
+//#endregion
+
 /**
  * Medication form options datasource (Tablet, Capsule, Syrup, Injection, etc.).
  */
@@ -451,205 +252,12 @@ class AXMSmokingStatusOptionsDataSourceDefinition {
     }
 }
 
-/** Allergy severity options (mild, moderate, severe). */
-class AXMAllergySeverityOptionsDataSourceDefinition {
-    constructor() {
-        this.definition = {
-            name: AXMHealthCoreDataSourceKeys.AllergySeverityOptions,
-            title: '@health-core:datasources.allergy-severity-options.title',
-            columns: [
-                { name: 'value', title: '@health-core:datasources.allergy-severity-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
-                { name: 'title', title: '@health-core:datasources.allergy-severity-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
-            ],
-            filters: [],
-            textField: { name: 'title', title: '@health-core:datasources.allergy-severity-options.columns.title.title' },
-            valueField: { name: 'value', title: '@health-core:datasources.allergy-severity-options.columns.value.title' },
-            samples: [
-                { value: 'mild', title: '@health-core:datasources.allergy-severity-options.samples.mild' },
-                { value: 'moderate', title: '@health-core:datasources.allergy-severity-options.samples.moderate' },
-                { value: 'severe', title: '@health-core:datasources.allergy-severity-options.samples.severe' },
-            ],
-            source: () => {
-                const items = [
-                    { value: 'mild', title: '@health-core:datasources.allergy-severity-options.samples.mild' },
-                    { value: 'moderate', title: '@health-core:datasources.allergy-severity-options.samples.moderate' },
-                    { value: 'severe', title: '@health-core:datasources.allergy-severity-options.samples.severe' },
-                ];
-                return new AXDataSource({
-                    pageSize: 10,
-                    key: 'value',
-                    load: async () => ({ items, total: items.length }),
-                    byKey: async (key) => items.find((item) => item.value === key),
-                });
-            },
-        };
-    }
-    async items() {
-        return [this.definition];
-    }
-}
-
-/** Chronic condition status options (active, managed, resolved). */
-class AXMChronicConditionStatusOptionsDataSourceDefinition {
-    constructor() {
-        this.definition = {
-            name: AXMHealthCoreDataSourceKeys.ChronicConditionStatusOptions,
-            title: '@health-core:datasources.chronic-condition-status-options.title',
-            columns: [
-                { name: 'value', title: '@health-core:datasources.chronic-condition-status-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
-                { name: 'title', title: '@health-core:datasources.chronic-condition-status-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
-            ],
-            filters: [],
-            textField: { name: 'title', title: '@health-core:datasources.chronic-condition-status-options.columns.title.title' },
-            valueField: { name: 'value', title: '@health-core:datasources.chronic-condition-status-options.columns.value.title' },
-            samples: [
-                { value: 'active', title: '@health-core:datasources.chronic-condition-status-options.samples.active' },
-                { value: 'managed', title: '@health-core:datasources.chronic-condition-status-options.samples.managed' },
-                { value: 'resolved', title: '@health-core:datasources.chronic-condition-status-options.samples.resolved' },
-            ],
-            source: () => {
-                const items = [
-                    { value: 'active', title: '@health-core:datasources.chronic-condition-status-options.samples.active' },
-                    { value: 'managed', title: '@health-core:datasources.chronic-condition-status-options.samples.managed' },
-                    { value: 'resolved', title: '@health-core:datasources.chronic-condition-status-options.samples.resolved' },
-                ];
-                return new AXDataSource({
-                    pageSize: 10,
-                    key: 'value',
-                    load: async () => ({ items, total: items.length }),
-                    byKey: async (key) => items.find((item) => item.value === key),
-                });
-            },
-        };
-    }
-    async items() {
-        return [this.definition];
-    }
-}
-
-const I18N$2 = '@health-core:datasources.injury-mechanism-options';
-const INJURY_MECHANISM_ITEMS = [
-    { id: 'slip_trip_fall', title: `${I18N$2}.samples.slip-trip-fall` },
-    { id: 'struck_by', title: `${I18N$2}.samples.struck-by` },
-    { id: 'struck_against', title: `${I18N$2}.samples.struck-against` },
-    { id: 'caught_in', title: `${I18N$2}.samples.caught-in` },
-    { id: 'overexertion', title: `${I18N$2}.samples.overexertion` },
-    { id: 'exposure', title: `${I18N$2}.samples.exposure` },
-    { id: 'vehicle', title: `${I18N$2}.samples.vehicle` },
-    { id: 'cut_puncture', title: `${I18N$2}.samples.cut-puncture` },
-    { id: 'other', title: `${I18N$2}.samples.other` },
-];
-/** Workplace injury mechanism options for occupational health questionnaires. */
-class AXMInjuryMechanismOptionsDataSourceDefinition {
-    constructor() {
-        this.definition = {
-            name: AXMHealthCoreDataSourceKeys.InjuryMechanismOptions,
-            title: `${I18N$2}.title`,
-            columns: [
-                { name: 'id', title: `${I18N$2}.columns.id.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-                { name: 'title', title: `${I18N$2}.columns.title.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-            ],
-            filters: [],
-            textField: { name: 'title', title: `${I18N$2}.columns.title.title` },
-            valueField: { name: 'id', title: `${I18N$2}.columns.id.title` },
-            samples: [...INJURY_MECHANISM_ITEMS],
-            source: () => {
-                const items = [...INJURY_MECHANISM_ITEMS];
-                return new AXDataSource({
-                    pageSize: 20,
-                    key: 'id',
-                    load: async () => ({ items, total: items.length }),
-                    byKey: async (key) => items.find((item) => item.id === key),
-                });
-            },
-        };
-    }
-    async items() {
-        return [this.definition];
-    }
-}
-
-const I18N$1 = '@health-core:datasources.work-capacity-options';
-const WORK_CAPACITY_ITEMS = [
-    { id: 'continue', title: `${I18N$1}.samples.continue` },
-    { id: 'modified', title: `${I18N$1}.samples.modified` },
-    { id: 'unable', title: `${I18N$1}.samples.unable` },
-    { id: 'hospitalised', title: `${I18N$1}.samples.hospitalised` },
-];
-/** Post-injury work capacity options for occupational health questionnaires. */
-class AXMWorkCapacityOptionsDataSourceDefinition {
-    constructor() {
-        this.definition = {
-            name: AXMHealthCoreDataSourceKeys.WorkCapacityOptions,
-            title: `${I18N$1}.title`,
-            columns: [
-                { name: 'id', title: `${I18N$1}.columns.id.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-                { name: 'title', title: `${I18N$1}.columns.title.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-            ],
-            filters: [],
-            textField: { name: 'title', title: `${I18N$1}.columns.title.title` },
-            valueField: { name: 'id', title: `${I18N$1}.columns.id.title` },
-            samples: [...WORK_CAPACITY_ITEMS],
-            source: () => {
-                const items = [...WORK_CAPACITY_ITEMS];
-                return new AXDataSource({
-                    pageSize: 10,
-                    key: 'id',
-                    load: async () => ({ items, total: items.length }),
-                    byKey: async (key) => items.find((item) => item.id === key),
-                });
-            },
-        };
-    }
-    async items() {
-        return [this.definition];
-    }
-}
-
-const I18N = '@health-core:datasources.pain-rate-options';
-const PAIN_RATE_ITEMS = [
-    { id: '1', title: `${I18N}.samples.1` },
-    { id: '2', title: `${I18N}.samples.2` },
-    { id: '3', title: `${I18N}.samples.3` },
-    { id: '4', title: `${I18N}.samples.4` },
-    { id: '5', title: `${I18N}.samples.5` },
-];
-/** Current pain severity scale (1–5) for workplace injury questionnaires. */
-class AXMPainRateOptionsDataSourceDefinition {
-    constructor() {
-        this.definition = {
-            name: AXMHealthCoreDataSourceKeys.PainRateOptions,
-            title: `${I18N}.title`,
-            columns: [
-                { name: 'id', title: `${I18N}.columns.id.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-                { name: 'title', title: `${I18N}.columns.title.title`, type: AXPWidgetsCatalog.text, datatype: 'string' },
-            ],
-            filters: [],
-            textField: { name: 'title', title: `${I18N}.columns.title.title` },
-            valueField: { name: 'id', title: `${I18N}.columns.id.title` },
-            samples: [...PAIN_RATE_ITEMS],
-            source: () => {
-                const items = [...PAIN_RATE_ITEMS];
-                return new AXDataSource({
-                    pageSize: 10,
-                    key: 'id',
-                    load: async () => ({ items, total: items.length }),
-                    byKey: async (key) => items.find((item) => item.id === key),
-                });
-            },
-        };
-    }
-    async items() {
-        return [this.definition];
-    }
-}
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Data Source Provider   ----
 /**
  * Health Core Data Source Provider.
- * Provides health-related choice datasources (medication form, risk level, alcohol, smoking, workplace injury).
+ * Provides health-related choice datasources (medication form, risk level, alcohol, smoking).
  */
 class AXMHealthCoreDataSourceProvider {
     constructor() {
@@ -657,11 +265,6 @@ class AXMHealthCoreDataSourceProvider {
         this.healthRiskLevelOptions = new AXMHealthRiskLevelOptionsDataSourceDefinition();
         this.alcoholConsumptionOptions = new AXMAlcoholConsumptionOptionsDataSourceDefinition();
         this.smokingStatusOptions = new AXMSmokingStatusOptionsDataSourceDefinition();
-        this.allergySeverityOptions = new AXMAllergySeverityOptionsDataSourceDefinition();
-        this.chronicConditionStatusOptions = new AXMChronicConditionStatusOptionsDataSourceDefinition();
-        this.injuryMechanismOptions = new AXMInjuryMechanismOptionsDataSourceDefinition();
-        this.workCapacityOptions = new AXMWorkCapacityOptionsDataSourceDefinition();
-        this.painRateOptions = new AXMPainRateOptionsDataSourceDefinition();
     }
     async items() {
         const items = await Promise.all([
@@ -669,244 +272,24 @@ class AXMHealthCoreDataSourceProvider {
             this.healthRiskLevelOptions.items(),
             this.alcoholConsumptionOptions.items(),
             this.smokingStatusOptions.items(),
-            this.allergySeverityOptions.items(),
-            this.chronicConditionStatusOptions.items(),
-            this.injuryMechanismOptions.items(),
-            this.workCapacityOptions.items(),
-            this.painRateOptions.items(),
         ]);
         return items.flat();
     }
 }
 //#endregion
 
-//#region ---- Imports ----
-//#endregion
-//#region ---- Icon helpers ----
-function healthEventMenuIconSuffix(icon) {
-    const trimmed = icon?.trim();
-    if (!trimmed) {
-        return 'fa-circle-plus';
-    }
-    const rest = trimmed.replace(/^(fa-(?:duotone|solid|regular|light|thin|brands))\s+/i, '').trim();
-    return rest || 'fa-circle-plus';
-}
-function resolveSubjectTitleExpression(subjectType) {
-    if (subjectType === 'HumanCapitalManagement.Employee') {
-        return '{{ context.eval("person.fullName") || context.eval("employeeCode") }}';
-    }
-    if (subjectType === 'PersonCore.Person') {
-        return '{{ context.eval("fullName") || (context.eval("firstName") + " " + context.eval("lastName")) }}';
-    }
-    return '{{ context.eval("title", { pipes: ["translate"] }) || context.eval("id") }}';
-}
-//#endregion
-/**
- * Expression-evaluator scope for health event guided-start dropdown items.
- */
-class AXMHealthCoreHealthEventExpressionEvaluatorScopeProvider {
-    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 health record types and returns toolbar child actions for guided create.
-             * @param subjectType Entity key for the polymorphic subject (e.g. HumanCapitalManagement.Employee).
-             */
-            HealthEvents: async (subjectType) => {
-                const resolvedSubjectType = String(subjectType ?? '').trim();
-                if (!resolvedSubjectType) {
-                    return [];
-                }
-                try {
-                    const locale = this.translation.getActiveLang();
-                    const page = await this.entityService
-                        .withEntity(RootConfig.module.name, RootConfig.entities.healthRecordType.name)
-                        .data()
-                        .query({ skip: 0, take: 500 });
-                    const rows = (page.items ?? []);
-                    const sorted = [...rows].sort((a, b) => {
-                        const ta = resolveMultiLanguageString(a.title, locale).trim() || a.id;
-                        const tb = resolveMultiLanguageString(b.title, locale).trim() || b.id;
-                        return ta.localeCompare(tb, locale, { sensitivity: 'base' });
-                    });
-                    const subjectTitleExpr = resolveSubjectTitleExpression(resolvedSubjectType);
-                    return sorted.map((row) => {
-                        const menuTitle = resolveMultiLanguageString(row.title, locale).trim() || row.id;
-                        const workflowConfig = row.workflowConfig;
-                        const workflowId = workflowConfig?.workflowName?.trim();
-                        const defaultInput = workflowConfig?.defaultInput ?? {};
-                        const questionnaireId = get(defaultInput, 'questionnaireId');
-                        const requireEmployeeSignature = get(defaultInput, 'requireEmployeeSignature');
-                        const requireManagerSignature = get(defaultInput, 'requireManagerSignature');
-                        const guidedFlowCommand = workflowId
-                            ? {
-                                name: AXMHealthCoreCommandKeys.HealthEvent.StartFlow,
-                                options: {
-                                    workflowId,
-                                    input: {
-                                        subjectType: resolvedSubjectType,
-                                        subjectId: '{{ context.eval("id") }}',
-                                        subjectTitle: subjectTitleExpr,
-                                        recordTypeId: row.id,
-                                        recordTypeTitle: row.title,
-                                        questionnaireId,
-                                        requireEmployeeSignature,
-                                        requireManagerSignature,
-                                    },
-                                },
-                            }
-                            : undefined;
-                        const notImplementedToastCommand = {
-                            name: 'workflow-activity:show-toast',
-                            options: {
-                                message: '@health-core:health-events.messages.event-not-implemented',
-                                type: 'warning',
-                            },
-                        };
-                        return {
-                            name: `start-health-event-${row.id}`,
-                            title: menuTitle,
-                            icon: healthEventMenuIconSuffix(row.icon),
-                            color: 'default',
-                            command: guidedFlowCommand ?? notImplementedToastCommand,
-                            priority: 'primary',
-                            type: 'info',
-                            scope: AXPEntityCommandScope.TypeLevel,
-                        };
-                    });
-                }
-                catch (error) {
-                    console.error(`${RootConfig.module.name}.HealthEvents failed:`, error instanceof Error ? error.message : error);
-                    return [];
-                }
-            },
-        });
-    }
-}
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Health event status ----
-/** Status lifecycle for health events: In progress → Waiting sign-off → Completed (or Cancelled). */
-class AXMHealthCoreHealthEventStatusProvider extends AXPStatusProvider {
-    constructor() {
-        super(...arguments);
-        this.key = 'health-core.status.health-event';
-        this.statuses = [
-            systemStatusToDefinition(AXPSystemStatusType.InProgress, {
-                title: '@health-core:health-events.states.in-progress',
-                generateView: true,
-            }),
-            systemStatusToDefinition(AXPSystemStatusType.WaitingSignOff, {
-                generateView: true,
-            }),
-            systemStatusToDefinition(AXPSystemStatusType.Completed, {
-                title: '@health-core:health-events.states.completed',
-                generateView: true,
-            }),
-            systemStatusToDefinition(AXPSystemStatusType.Cancelled, {
-                title: '@health-core:health-events.states.cancelled',
-                generateView: true,
-            }),
-        ];
-        this.transitions = [
-            {
-                from: AXPSystemStatusType.InProgress,
-                to: AXPSystemStatusType.WaitingSignOff,
-                title: '@health-core:health-events.transitions.await-sign-off',
-            },
-            {
-                from: AXPSystemStatusType.WaitingSignOff,
-                to: AXPSystemStatusType.Completed,
-                title: '@health-core:health-events.transitions.complete',
-            },
-            {
-                from: AXPSystemStatusType.WaitingSignOff,
-                to: AXPSystemStatusType.Cancelled,
-                title: '@general:statuses.transitions.cancel',
-            },
-            {
-                from: AXPSystemStatusType.InProgress,
-                to: AXPSystemStatusType.Cancelled,
-                title: '@general:statuses.transitions.cancel',
-            },
-        ];
-        this.defaultStatus = AXPSystemStatusType.InProgress;
-    }
-}
-//#endregion
-
-class AXMHealthCoreHealthEventFeatureModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreHealthEventFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreHealthEventFeatureModule, imports: [AXPRuntimeModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreHealthEventFeatureModule, providers: [
-            {
-                provide: AXP_STATUS_PROVIDERS,
-                useClass: AXMHealthCoreHealthEventStatusProvider,
-                multi: true,
-            },
-            {
-                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                useClass: AXMHealthCoreHealthEventExpressionEvaluatorScopeProvider,
-                multi: true,
-            },
-            provideCommandSetups([
-                {
-                    key: AXMHealthCoreCommandKeys.HealthEvent.StartFlow,
-                    command: () => import('./acorex-modules-health-core-start-health-record-flow.command-BzGYbiw_.mjs').then((c) => c.StartHealthEventFlowCommand),
-                },
-            ]),
-        ], imports: [AXPRuntimeModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreHealthEventFeatureModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [AXPRuntimeModule],
-                    providers: [
-                        {
-                            provide: AXP_STATUS_PROVIDERS,
-                            useClass: AXMHealthCoreHealthEventStatusProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
-                            useClass: AXMHealthCoreHealthEventExpressionEvaluatorScopeProvider,
-                            multi: true,
-                        },
-                        provideCommandSetups([
-                            {
-                                key: AXMHealthCoreCommandKeys.HealthEvent.StartFlow,
-                                command: () => import('./acorex-modules-health-core-start-health-record-flow.command-BzGYbiw_.mjs').then((c) => c.StartHealthEventFlowCommand),
-                            },
-                        ]),
-                    ],
-                }]
-        }] });
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Module   ----
 class AXMHealthCoreModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule, imports: [AXPRuntimeModule, AXMHealthCoreHealthEventFeatureModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule, providers: [
             {
                 provide: AXP_MODULE_MANIFEST_PROVIDER,
                 useValue: HealthCoreManifest,
                 multi: true,
             },
-            {
-                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
-                useClass: AXMHealthCoreCatalogScopeDefinitionProvider,
-                multi: true,
-            },
             provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMHealthCorePermissionDefinitionProvider)),
             provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMHealthCoreMenuProvider)),
             provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMHealthCoreEntityProvider)),
@@ -915,23 +298,18 @@ class AXMHealthCoreModule {
                 useClass: AXMHealthCoreDataSourceProvider,
                 multi: true,
             },
-        ], imports: [AXPRuntimeModule, AXMHealthCoreHealthEventFeatureModule] }); }
+        ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXPRuntimeModule, AXMHealthCoreHealthEventFeatureModule],
+                    imports: [],
                     providers: [
                         {
                             provide: AXP_MODULE_MANIFEST_PROVIDER,
                             useValue: HealthCoreManifest,
                             multi: true,
                         },
-                        {
-                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
-                            useClass: AXMHealthCoreCatalogScopeDefinitionProvider,
-                            multi: true,
-                        },
                         provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMHealthCorePermissionDefinitionProvider)),
                         provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMHealthCoreMenuProvider)),
                         provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMHealthCoreEntityProvider)),
@@ -944,1639 +322,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+//#region ----   Allergy Type Model   ----
 //#endregion
-//#region ----   Entity Factory   ----
-async function bloodTypeFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.bloodType.name,
-        title: RootConfig.entities.bloodType.title,
-        icon: RootConfig.entities.bloodType.icon,
-        formats: {
-            individual: RootConfig.entities.bloodType.title,
-            plural: RootConfig.entities.bloodType.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [
-            {
-                id: 'basic-info',
-                title: '@health-core:blood-types.entities.blood-type.groups.basic-info',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'uuid',
-                    visible: false,
-                    readonly: true,
-                    unique: { enabled: true },
-                },
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
-                        options: {
-                            placeholder: '@general:terms.common.title',
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
-                        options: {
-                            rows: 3,
-                            placeholder: '@general:terms.common.description',
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'description', options: { width: '280px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: {
-                    sections,
-                    properties: propertyLayouts,
-                },
-                update: {
-                    sections,
-                    properties: propertyLayouts,
-                },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var bloodType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    bloodTypeFactory: bloodTypeFactory
-});
 
+//#region ----   Blood Type Model   ----
 //#endregion
 
+//#region ----   Body Part Model   ----
 //#endregion
-//#region ----   Entity Factory   ----
-async function bodyPartFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.bodyPart.name,
-        title: RootConfig.entities.bodyPart.title,
-        icon: RootConfig.entities.bodyPart.icon,
-        formats: {
-            individual: RootConfig.entities.bodyPart.title,
-            plural: RootConfig.entities.bodyPart.titlePlural,
-            searchResult: { title: '{{ title }}', description: RootConfig.module.title },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [{ id: 'basic-info', title: '@health-core:body-parts.entities.body-part.groups.basic-info' }],
-        properties: [
-            { name: 'id', title: '@general:terms.common.id', groupId: 'basic-info', schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } } },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: '@general:terms.common.title' } },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3, placeholder: '@general:terms.common.description' } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'description', options: { width: '280px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: { title: '{{ title }}', sections, properties: propertyLayouts, actions: [...entityMasterRecordActions()] },
-                list: { actions: [...entityMasterCrudActions()], views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })] },
-            },
-        },
-    };
-    return entityDef;
-}
+
+//#region ----   Chronic Condition Type Model   ----
 //#endregion
 
-var bodyPart_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    bodyPartFactory: bodyPartFactory
-});
+//#region ----   Disability Status Model   ----
+//#endregion
 
+//#region ----   Injury Type Model   ----
 //#endregion
 
-//#endregion
-//#region ----   Entity Factory   ----
-async function disabilityStatusFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.disabilityStatus.name,
-        title: RootConfig.entities.disabilityStatus.title,
-        icon: RootConfig.entities.disabilityStatus.icon,
-        formats: {
-            individual: RootConfig.entities.disabilityStatus.title,
-            plural: RootConfig.entities.disabilityStatus.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: RootConfig.module.title,
-            },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [
-            {
-                id: 'basic-info',
-                title: '@health-core:disability-statuses.entities.disability-status.groups.basic-info',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'uuid',
-                    visible: false,
-                    readonly: true,
-                    unique: { enabled: true },
-                },
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
-                        options: {
-                            placeholder: '@general:terms.common.title',
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
-                        options: {
-                            rows: 3,
-                            placeholder: '@general:terms.common.description',
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'description', options: { width: '280px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: {
-                    sections,
-                    properties: propertyLayouts,
-                },
-                update: {
-                    sections,
-                    properties: propertyLayouts,
-                },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var disabilityStatus_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    disabilityStatusFactory: disabilityStatusFactory
-});
-
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Repeater children ----
-const RESTRICTIONS_REPEATER_CHILDREN = [
-    {
-        type: AXPWidgetsList.Layouts.GridLayout,
-        mode: 'edit',
-        name: 'restrictionRow',
-        options: {
-            grid: {
-                default: {
-                    columns: 12,
-                    gap: '1rem',
-                },
-            },
-        },
-        children: [
-            {
-                type: AXPWidgetsList.Layouts.GridItemLayout,
-                mode: 'edit',
-                options: { colSpan: 6 },
-                children: [
-                    {
-                        type: AXPWidgetsList.Layouts.FormField,
-                        mode: 'edit',
-                        options: {
-                            label: '@health-core:health-conditions.entities.health-condition.fields.restriction-id',
-                            showLabel: true,
-                        },
-                        children: [
-                            {
-                                type: AXPWidgetsList.Editors.LookupBox,
-                                mode: 'edit',
-                                path: 'restrictionId',
-                                name: 'restrictionId',
-                                options: {
-                                    entity: `${RootConfig.module.name}.${RootConfig.entities.healthRestriction.name}`,
-                                    textField: 'title',
-                                    valueField: 'id',
-                                    look: 'select',
-                                    columns: ['title', 'description'],
-                                    expose: [
-                                        { source: 'id', target: 'restriction.id' },
-                                        { source: 'title', target: 'restriction.title' },
-                                    ],
-                                    validations: [{ rule: 'required' }],
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                type: AXPWidgetsList.Layouts.GridItemLayout,
-                mode: 'edit',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: AXPWidgetsList.Layouts.FormField,
-                        mode: 'edit',
-                        options: {
-                            label: '@health-core:health-conditions.entities.health-condition.fields.start-date',
-                            showLabel: true,
-                        },
-                        children: [
-                            {
-                                type: AXPWidgetsList.Editors.DateTimeBox,
-                                mode: 'edit',
-                                path: 'startDate',
-                                name: 'startDate',
-                                options: {},
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                type: AXPWidgetsList.Layouts.GridItemLayout,
-                mode: 'edit',
-                options: { colSpan: 3 },
-                children: [
-                    {
-                        type: AXPWidgetsList.Layouts.FormField,
-                        mode: 'edit',
-                        options: {
-                            label: '@health-core:health-conditions.entities.health-condition.fields.end-date',
-                            showLabel: true,
-                        },
-                        children: [
-                            {
-                                type: AXPWidgetsList.Editors.DateTimeBox,
-                                mode: 'edit',
-                                path: 'endDate',
-                                name: 'endDate',
-                                options: {},
-                            },
-                        ],
-                    },
-                ],
-            },
-        ],
-    },
-];
-//#endregion
-//#region ---- Entity Factory ----
-async function healthConditionFactory() {
-    const sections = [
-        { id: 'condition-details', layout: { positions: { lg: { colSpan: 12 } } } },
-        { id: 'restrictions', order: 3, layout: { positions: { lg: { colSpan: 12 } } } },
-    ];
-    const restrictionsPropertyLayout = {
-        name: 'restrictions',
-        layout: { label: { visible: false }, positions: { lg: { colSpan: 12 } } },
-    };
-    const viewPropertyLayouts = [
-        { name: 'subject.id', layout: { positions: { lg: { colSpan: 12 } } } },
-        { name: 'conditionTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
-        { name: 'diagnosedDate', layout: { positions: { lg: { colSpan: 6 } } } },
-        { name: 'notes', layout: { positions: { lg: { colSpan: 12 } } } },
-        restrictionsPropertyLayout,
-    ];
-    const editPropertyLayouts = omitHealthSubjectFromEditLayouts(viewPropertyLayouts);
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthCondition.name,
-        title: RootConfig.entities.healthCondition.title,
-        icon: RootConfig.entities.healthCondition.icon,
-        plugins: [
-            { name: 'history' },
-            {
-                name: 'meta-data-form',
-                options: {
-                    title: '@health-core:health-conditions.entities.health-condition.groups.more-information',
-                    path: 'conditionTypeId',
-                    display: {
-                        section: {
-                            order: 2,
-                        },
-                    },
-                },
-            },
-        ],
-        formats: {
-            individual: RootConfig.entities.healthCondition.title,
-            plural: RootConfig.entities.healthCondition.titlePlural,
-            searchResult: {
-                title: '{{ context.eval("conditionType.title", { pipes: ["translate"] }) }}',
-                description: '{{ context.eval("subject.title", { pipes: ["translate"] }) }}',
-            },
-        },
-        groups: [
-            {
-                id: 'condition-details',
-                title: '@health-core:health-conditions.entities.health-condition.groups.condition-details',
-            },
-            {
-                id: 'restrictions',
-                title: '@health-core:health-conditions.entities.health-condition.groups.restrictions',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'condition-details',
-                schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } },
-            },
-            createHealthSubjectLookupProperty('condition-details', { readonly: true }),
-            {
-                name: 'conditionTypeId',
-                title: '@health-core:health-conditions.entities.health-condition.fields.condition-type-id',
-                groupId: 'condition-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.healthConditionType.name}`,
-                            textField: 'title',
-                            valueField: 'id',
-                            look: 'select',
-                            columns: ['title', 'kind'],
-                            expose: [
-                                { source: 'id', target: 'conditionType.id' },
-                                { source: 'title', target: 'conditionType.title' },
-                                { source: 'kind', target: 'conditionType.kind' },
-                            ],
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'diagnosedDate',
-                title: '@health-core:health-conditions.entities.health-condition.fields.diagnosed-date',
-                groupId: 'condition-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'date',
-                    interface: { type: AXPWidgetsList.Editors.DateTimeBox },
-                },
-            },
-            {
-                name: 'restrictions',
-                title: '@health-core:health-conditions.entities.health-condition.fields.restrictions.title',
-                groupId: 'restrictions',
-                schema: {
-                    defaultValue: [],
-                    dataType: 'array',
-                    interface: {
-                        type: AXPWidgetsList.Layouts.RepeaterLayout,
-                        options: { hasControls: true },
-                        children: [...RESTRICTIONS_REPEATER_CHILDREN],
-                    },
-                },
-            },
-            {
-                name: 'notes',
-                title: '@general:terms.common.notes',
-                groupId: 'condition-details',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 2 } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'conditionTypeId', options: { dataPath: 'conditionType.title', width: '300px' } },
-            { name: 'diagnosedDate', options: { width: '150px' } },
-            { name: 'restrictions', options: { width: '280px' } },
-            { name: 'notes', options: { width: '300px' } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: editPropertyLayouts },
-                update: { sections, properties: editPropertyLayouts },
-                single: {
-                    title: '{{ context.eval("conditionType.title", { pipes: ["translate"] }) }}',
-                    sections,
-                    properties: viewPropertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [createAllQueryView({ sorts: [{ name: 'diagnosedDate', dir: 'desc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthCondition_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthConditionFactory: healthConditionFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Entity Factory ----
-async function healthConditionTypeFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
-        { name: 'kind', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'suggestedRestrictionIds', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthConditionType.name,
-        title: RootConfig.entities.healthConditionType.title,
-        icon: RootConfig.entities.healthConditionType.icon,
-        formats: {
-            individual: RootConfig.entities.healthConditionType.title,
-            plural: RootConfig.entities.healthConditionType.titlePlural,
-            searchResult: { title: '{{ title }}', description: '{{ kind }}' },
-        },
-        plugins: [
-            { name: 'meta-data-builder', options: { display: 'page' } },
-            { name: 'history' },
-            { name: 'compare' },
-            { name: 'clone' },
-        ],
-        groups: [
-            {
-                id: 'basic-info',
-                title: '@health-core:health-condition-types.entities.health-condition-type.groups.basic-info',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'basic-info',
-                schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } },
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: { dataType: 'string', interface: { type: AXPWidgetsList.Editors.TextBox } },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'kind',
-                title: '@health-core:health-condition-types.entities.health-condition-type.fields.kind',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            dataSource: [
-                                { value: 'allergy', title: '@health-core:health-condition-types.kinds.allergy' },
-                                { value: 'chronic', title: '@health-core:health-condition-types.kinds.chronic' },
-                            ],
-                            valueField: 'value',
-                            textField: 'title',
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3 } },
-                },
-            },
-            {
-                name: 'suggestedRestrictionIds',
-                title: '@health-core:health-condition-types.entities.health-condition-type.fields.suggested-restriction-ids',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'array',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.healthRestriction.name}`,
-                            textField: 'title',
-                            valueField: 'id',
-                            look: 'select',
-                            multiple: true,
-                            hasClearButton: true,
-                            columns: ['title', 'description'],
-                            expose: [
-                                { source: 'id', target: 'suggestedRestrictions.{id}' },
-                                { source: 'title', target: 'suggestedRestrictions.{title}' },
-                            ],
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'kind', options: { width: '120px', order: 2 } },
-            { name: 'description', options: { width: '280px', order: 3 } },
-            { name: 'suggestedRestrictionIds', options: { dataPath: 'suggestedRestrictions', width: '240px', order: 4 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthConditionType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthConditionTypeFactory: healthConditionTypeFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Shared property layouts ----
-const eventDetailsViewProperties = [
-    { name: 'subject.id', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-    { name: 'recordTypeId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    { name: 'occurredDate', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
-    { name: 'endDate', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-    { name: 'provider', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-    { name: 'facility', layout: { positions: { lg: { colSpan: 6, order: 6 } } } },
-    { name: 'notes', layout: { positions: { lg: { colSpan: 12, order: 7 } } } },
-    { name: 'employeeSignature', layout: { positions: { lg: { colSpan: 6 } } } },
-    { name: 'employeeSignedAt', layout: { positions: { lg: { colSpan: 6 } } } },
-    { name: 'managerSignature', layout: { positions: { lg: { colSpan: 6 } } } },
-    { name: 'managerSignedAt', layout: { positions: { lg: { colSpan: 6 } } } },
-];
-const eventDetailsEditProperties = omitHealthSubjectFromEditLayouts(eventDetailsViewProperties);
-//#endregion
-//#region ---- Entity Factory ----
-async function healthEventFactory() {
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthEvent.name,
-        title: RootConfig.entities.healthEvent.title,
-        icon: RootConfig.entities.healthEvent.icon,
-        plugins: [
-            { name: 'history' },
-            {
-                name: 'attachments',
-                options: {
-                    showListAction: false,
-                },
-            },
-            {
-                name: 'workflow-run',
-                options: {
-                    list: {
-                        mode: 'workflow-run',
-                    },
-                },
-            },
-            {
-                name: 'status',
-                options: {
-                    field: 'statusId',
-                    definition: 'health-core.status.health-event',
-                },
-            },
-            {
-                name: 'meta-data-form',
-                options: {
-                    title: '@health-core:health-events.entities.health-event.groups.more-information',
-                    path: 'recordTypeId',
-                    display: 'section',
-                },
-            },
-        ],
-        formats: {
-            individual: RootConfig.entities.healthEvent.title,
-            plural: RootConfig.entities.healthEvent.titlePlural,
-            searchResult: {
-                title: '{{ context.eval("recordType.title", { pipes: ["translate"] }) }}',
-                description: '{{ context.eval("subject.title", { pipes: ["translate"] }) }}',
-            },
-        },
-        groups: [
-            {
-                id: 'event-details',
-                title: '@health-core:health-events.entities.health-event.groups.event-details',
-            },
-            {
-                id: 'sign-off',
-                title: '@health-core:health-events.entities.health-event.groups.sign-off',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: 'ID',
-                groupId: 'event-details',
-                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
-            },
-            createHealthSubjectLookupProperty('event-details', { readonly: true }),
-            {
-                name: 'recordTypeId',
-                title: '@health-core:health-events.entities.health-event.fields.record-type-id',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.healthRecordType.name}`,
-                            textField: 'title',
-                            valueField: 'id',
-                            look: 'select',
-                            columns: ['title'],
-                            expose: [
-                                { source: 'id', target: 'recordType.id' },
-                                { source: 'title', target: 'recordType.title' },
-                            ],
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'occurredDate',
-                title: '@health-core:health-events.entities.health-event.fields.occurred-date',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'date',
-                    defaultValue: '{{ date.today() }}',
-                    interface: { type: AXPWidgetsList.Editors.DateTimeBox },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'endDate',
-                title: '@health-core:health-events.entities.health-event.fields.end-date',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'date',
-                    nullable: true,
-                    interface: { type: AXPWidgetsList.Editors.DateTimeBox },
-                },
-            },
-            {
-                name: 'provider',
-                title: '@health-core:health-events.entities.health-event.fields.provider.title',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
-                        options: {
-                            placeholder: '@health-core:health-events.entities.health-event.fields.provider.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'facility',
-                title: '@health-core:health-events.entities.health-event.fields.facility.title',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
-                        options: {
-                            placeholder: '@health-core:health-events.entities.health-event.fields.facility.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'notes',
-                title: '@general:terms.common.notes',
-                groupId: 'event-details',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3 } },
-                },
-            },
-            {
-                name: 'employeeSignature',
-                title: '@health-core:health-events.entities.health-event.fields.employee-signature',
-                groupId: 'sign-off',
-                schema: {
-                    dataType: 'string',
-                    nullable: true,
-                    readonly: true,
-                    interface: { type: AXPWidgetsList.Editors.SignatureBox },
-                },
-            },
-            {
-                name: 'employeeSignedAt',
-                title: '@health-core:health-events.entities.health-event.fields.employee-signed-at',
-                groupId: 'sign-off',
-                schema: {
-                    dataType: 'date',
-                    nullable: true,
-                    readonly: true,
-                    interface: { type: AXPWidgetsList.Editors.DateTimeBox },
-                },
-            },
-            {
-                name: 'managerSignature',
-                title: '@health-core:health-events.entities.health-event.fields.manager-signature',
-                groupId: 'sign-off',
-                schema: {
-                    dataType: 'string',
-                    nullable: true,
-                    readonly: true,
-                    interface: { type: AXPWidgetsList.Editors.SignatureBox },
-                },
-            },
-            {
-                name: 'managerSignedAt',
-                title: '@health-core:health-events.entities.health-event.fields.manager-signed-at',
-                groupId: 'sign-off',
-                schema: {
-                    dataType: 'date',
-                    nullable: true,
-                    readonly: true,
-                    interface: { type: AXPWidgetsList.Editors.DateTimeBox },
-                },
-            },
-        ],
-        columns: [
-            { name: 'recordTypeId', options: { dataPath: 'recordType.title' } },
-            { name: 'occurredDate' },
-            { name: 'endDate' },
-            { name: 'provider' },
-            { name: 'statusId' },
-            { name: 'subject.id', options: { dataPath: 'subject.title' } },
-        ],
-        relatedEntities: [],
-        interfaces: {
-            master: {
-                create: {
-                    sections: [{ id: 'event-details' }],
-                    properties: eventDetailsEditProperties,
-                },
-                update: {
-                    sections: [{ id: 'event-details' }],
-                    properties: eventDetailsEditProperties,
-                },
-                single: {
-                    title: '{{ context.eval("subject.title", { pipes: ["translate"] }) + " - " + context.eval("recordType.title", { pipes: ["translate"] }) + " - " + context.eval("occurredDate", { pipes: ["date"] }) }}',
-                    sections: [
-                        { id: 'event-details', order: 1 },
-                        { id: 'sign-off', order: 2 },
-                    ],
-                    properties: eventDetailsViewProperties,
-                    actions: entityMasterRecordActions(),
-                },
-                list: {
-                    actions: [...entityMasterCrudActions({ create: false, delete: false, view: false })],
-                    views: [createAllQueryView({ sorts: [{ name: 'occurredDate', dir: 'desc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthEvent_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthEventFactory: healthEventFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Entity Factory ----
-async function healthRecordTypeFactory() {
-    const sections = [{ id: 'basic-info' }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthRecordType.name,
-        title: RootConfig.entities.healthRecordType.title,
-        icon: RootConfig.entities.healthRecordType.icon,
-        plugins: [
-            { name: 'meta-data-builder', options: { display: 'page' } },
-            { name: 'icon' },
-            { name: 'clone' },
-            { name: 'history' },
-            {
-                name: 'workflow-selector',
-                options: {
-                    templateInputNames: ['questionnaireId', 'requireEmployeeSignature', 'requireManagerSignature'],
-                    catalogScopeKeys: [HEALTH_CATALOG_SCOPE],
-                    templateInputFilters: {
-                        questionnaireId: {
-                            catalogScopeKeys: [HEALTH_CATALOG_SCOPE],
-                        },
-                    },
-                },
-            },
-        ],
-        formats: {
-            individual: RootConfig.entities.healthRecordType.title,
-            plural: RootConfig.entities.healthRecordType.titlePlural,
-            searchResult: { title: '{{ title }}', description: '{{ description }}' },
-        },
-        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } },
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox },
-                },
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3 } },
-                },
-            },
-        ],
-        columns: [{ name: 'title' }, { name: 'description' }],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: {
-                    title: '{{ title }}',
-                    sections: [{ id: 'basic-info', order: 1, layout: { positions: { lg: { colSpan: 12 } } } }],
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthRecordType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthRecordTypeFactory: healthRecordTypeFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Form layouts ----
-const profilePropertyLayouts = [
-    { name: 'subject.id', layout: { positions: { lg: { colSpan: 12 } } } },
-    // Row 1: 4 + 4 + 4
-    { name: 'disabilityStatusId', layout: { positions: { lg: { colSpan: 4, colStart: 1 } } } },
-    { name: 'smokingStatus', layout: { positions: { lg: { colSpan: 4, colStart: 5 } } } },
-    { name: 'alcoholConsumption', layout: { positions: { lg: { colSpan: 4, colStart: 9 } } } },
-    // Row 2: 4 + 4
-    { name: 'bloodTypeId', layout: { positions: { lg: { colSpan: 4, colStart: 1 } } } },
-    { name: 'healthRiskLevel', layout: { positions: { lg: { colSpan: 4, colStart: 5 } } } },
-    // Row 3: 4 + 4
-    { name: 'doctorName', layout: { positions: { lg: { colSpan: 4, colStart: 1 } } } },
-    { name: 'doctorNumber', layout: { positions: { lg: { colSpan: 4, colStart: 5 } } } },
-    // Row 4: 4 + 4 + 4
-    { name: 'emergencyContactName', layout: { positions: { lg: { colSpan: 4, colStart: 1 } } } },
-    { name: 'emergencyContactPhone', layout: { positions: { lg: { colSpan: 4, colStart: 5 } } } },
-    { name: 'emergencyContactEmail', layout: { positions: { lg: { colSpan: 4, colStart: 9 } } } },
-    // Row 5: 12
-    { name: 'notes', layout: { positions: { lg: { colSpan: 12, colStart: 1 } } } },
-];
-//#endregion
-//#region ---- Entity Factory ----
-async function healthProfileFactory() {
-    const sections = [{ id: 'profile-details', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = omitHealthSubjectFromEditLayouts(profilePropertyLayouts);
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthProfile.name,
-        title: RootConfig.entities.healthProfile.title,
-        icon: RootConfig.entities.healthProfile.icon,
-        formats: {
-            individual: RootConfig.entities.healthProfile.title,
-            plural: RootConfig.entities.healthProfile.titlePlural,
-            searchResult: { title: '{{ subject.title }}', description: RootConfig.module.title },
-        },
-        plugins: [{ name: 'history' }],
-        groups: [
-            {
-                id: 'profile-details',
-                title: '@health-core:health-profiles.entities.health-profile.groups.profile-details',
-            },
-        ],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'profile-details',
-                schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } },
-            },
-            createHealthSubjectLookupProperty('profile-details', { readonly: true }),
-            {
-                name: 'disabilityStatusId',
-                title: '@health-core:health-profiles.entities.health-profile.fields.disability-status-id',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.disabilityStatus.name}`,
-                            textField: 'title',
-                            valueField: 'id',
-                            look: 'select',
-                            expose: [
-                                { source: 'id', target: 'disabilityStatus.id' },
-                                { source: 'title', target: 'disabilityStatus.title' },
-                            ],
-                        },
-                    },
-                },
-            },
-            {
-                name: 'smokingStatus',
-                title: '@health-core:health-profiles.entities.health-profile.fields.smoking-status',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            dataSource: AXMHealthCoreDataSourceKeys.SmokingStatusOptions,
-                            valueField: 'value',
-                            textField: 'title',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'alcoholConsumption',
-                title: '@health-core:health-profiles.entities.health-profile.fields.alcohol-consumption',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            dataSource: AXMHealthCoreDataSourceKeys.AlcoholConsumptionOptions,
-                            valueField: 'value',
-                            textField: 'title',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'bloodTypeId',
-                title: '@health-core:health-profiles.entities.health-profile.fields.blood-type-id',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.bloodType.name}`,
-                            textField: 'title',
-                            valueField: 'id',
-                            look: 'select',
-                            expose: [
-                                { source: 'id', target: 'bloodType.id' },
-                                { source: 'title', target: 'bloodType.title' },
-                            ],
-                        },
-                    },
-                },
-            },
-            {
-                name: 'healthRiskLevel',
-                title: '@health-core:health-profiles.entities.health-profile.fields.health-risk-level',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            dataSource: AXMHealthCoreDataSourceKeys.HealthRiskLevelOptions,
-                            valueField: 'value',
-                            textField: 'title',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'doctorName',
-                title: '@health-core:health-profiles.entities.health-profile.fields.doctor-name',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox },
-                },
-            },
-            {
-                name: 'doctorNumber',
-                title: '@health-core:health-profiles.entities.health-profile.fields.doctor-number',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.ContactBox,
-                        options: { type: 'phone', hasLabel: false, hasIcon: true },
-                    },
-                },
-            },
-            {
-                name: 'emergencyContactName',
-                title: '@health-core:health-profiles.entities.health-profile.fields.emergency-contact-name',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox },
-                },
-            },
-            {
-                name: 'emergencyContactPhone',
-                title: '@health-core:health-profiles.entities.health-profile.fields.emergency-contact-phone',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.ContactBox,
-                        options: { type: 'phone', hasLabel: false, hasIcon: true },
-                    },
-                },
-            },
-            {
-                name: 'emergencyContactEmail',
-                title: '@health-core:health-profiles.entities.health-profile.fields.emergency-contact-email',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.ContactBox,
-                        options: { type: 'email', hasLabel: false, hasIcon: true },
-                    },
-                },
-            },
-            {
-                name: 'notes',
-                title: '@general:terms.common.notes',
-                groupId: 'profile-details',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3 } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'subject.id', options: { dataPath: 'subject.title' } },
-            { name: 'bloodTypeId', options: { dataPath: 'bloodType.title' } },
-            { name: 'disabilityStatusId', options: { dataPath: 'disabilityStatus.title' } },
-            { name: 'healthRiskLevel' },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: {
-                    title: '{{ subject.title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [createAllQueryView({ sorts: [{ name: 'subject.id', dir: 'asc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthProfile_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthProfileFactory: healthProfileFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-//#region ---- Entity Factory ----
-async function healthRestrictionFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.healthRestriction.name,
-        title: RootConfig.entities.healthRestriction.title,
-        icon: RootConfig.entities.healthRestriction.icon,
-        formats: {
-            individual: RootConfig.entities.healthRestriction.title,
-            plural: RootConfig.entities.healthRestriction.titlePlural,
-            searchResult: { title: '{{ title }}', description: '{{ description }}' },
-        },
-        plugins: [
-            { name: 'history' },
-            { name: 'compare' },
-            { name: 'clone' },
-            { name: 'category', options: { appearance: { icon: true, color: true }, metaData: { enabled: true } } },
-            { name: 'meta-data-form', options: { path: 'categoryIds' } },
-        ],
-        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'basic-info',
-                schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } },
-            },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: '@general:terms.common.title' } },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3 } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '260px', order: 1 } },
-            { name: 'description', options: { width: '320px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var healthRestriction_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    healthRestrictionFactory: healthRestrictionFactory
-});
-
-//#region ---- Imports ----
-//#endregion
-
-//#endregion
-//#region ----   Entity Factory   ----
-async function injuryTypeFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.injuryType.name,
-        title: RootConfig.entities.injuryType.title,
-        icon: RootConfig.entities.injuryType.icon,
-        formats: {
-            individual: RootConfig.entities.injuryType.title,
-            plural: RootConfig.entities.injuryType.titlePlural,
-            searchResult: { title: '{{ title }}', description: RootConfig.module.title },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [{ id: 'basic-info', title: '@health-core:injury-types.entities.injury-type.groups.basic-info' }],
-        properties: [
-            { name: 'id', title: '@general:terms.common.id', groupId: 'basic-info', schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } } },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: '@general:terms.common.title' } },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3, placeholder: '@general:terms.common.description' } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'description', options: { width: '280px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: { title: '{{ title }}', sections, properties: propertyLayouts, actions: [...entityMasterRecordActions()] },
-                list: { actions: [...entityMasterCrudActions()], views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })] },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var injuryType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    injuryTypeFactory: injuryTypeFactory
-});
-
-//#endregion
-
-//#endregion
-//#region ----   Entity Factory   ----
-async function vaccinationTypeFactory() {
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.vaccinationType.name,
-        title: RootConfig.entities.vaccinationType.title,
-        icon: RootConfig.entities.vaccinationType.icon,
-        formats: {
-            individual: RootConfig.entities.vaccinationType.title,
-            plural: RootConfig.entities.vaccinationType.titlePlural,
-            searchResult: { title: '{{ title }}', description: RootConfig.module.title },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [{ id: 'basic-info', title: '@health-core:vaccination-types.entities.vaccination-type.groups.basic-info' }],
-        properties: [
-            { name: 'id', title: '@general:terms.common.id', groupId: 'basic-info', schema: { dataType: 'uuid', visible: false, readonly: true, unique: { enabled: true } } },
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
-                options: { sort: { enabled: true }, filter: { advance: { enabled: true }, inline: { enabled: true } } },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.TextBox, options: { placeholder: '@general:terms.common.title' } },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: { type: AXPWidgetsList.Editors.LargeTextBox, options: { rows: 3, placeholder: '@general:terms.common.description' } },
-                },
-            },
-        ],
-        columns: [
-            { name: 'title', options: { width: '220px', order: 1 } },
-            { name: 'description', options: { width: '280px', order: 2 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: { title: '{{ title }}', sections, properties: propertyLayouts, actions: [...entityMasterRecordActions()] },
-                list: { actions: [...entityMasterCrudActions()], views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })] },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var vaccinationType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    vaccinationTypeFactory: vaccinationTypeFactory
-});
-
+//#region ----   Vaccination Type Model   ----
 //#endregion
 
 //#region ----   Imports   ----
@@ -2588,28 +352,20 @@ class AXMHealthCoreEntityProvider {
             return null;
         }
         switch (entityName) {
+            case RootConfig.entities.allergyType.name:
+                return (await import('./acorex-modules-health-core-allergy-type.entity-Ba06KigW.mjs')).allergyTypeFactory();
             case RootConfig.entities.bloodType.name:
-                return (await Promise.resolve().then(function () { return bloodType_entity; })).bloodTypeFactory();
+                return (await import('./acorex-modules-health-core-blood-type.entity-165JDo8r.mjs')).bloodTypeFactory();
             case RootConfig.entities.bodyPart.name:
-                return (await Promise.resolve().then(function () { return bodyPart_entity; })).bodyPartFactory();
+                return (await import('./acorex-modules-health-core-body-part.entity-CGk798g1.mjs')).bodyPartFactory();
+            case RootConfig.entities.chronicConditionType.name:
+                return (await import('./acorex-modules-health-core-chronic-condition-type.entity-CHeAJ1Mm.mjs')).chronicConditionTypeFactory();
             case RootConfig.entities.disabilityStatus.name:
-                return (await Promise.resolve().then(function () { return disabilityStatus_entity; })).disabilityStatusFactory();
+                return (await import('./acorex-modules-health-core-disability-status.entity-DN5reubi.mjs')).disabilityStatusFactory();
             case RootConfig.entities.injuryType.name:
-                return (await Promise.resolve().then(function () { return injuryType_entity; })).injuryTypeFactory();
+                return (await import('./acorex-modules-health-core-injury-type.entity-x9bs6Zly.mjs')).injuryTypeFactory();
             case RootConfig.entities.vaccinationType.name:
-                return (await Promise.resolve().then(function () { return vaccinationType_entity; })).vaccinationTypeFactory();
-            case RootConfig.entities.healthConditionType.name:
-                return (await Promise.resolve().then(function () { return healthConditionType_entity; })).healthConditionTypeFactory();
-            case RootConfig.entities.healthRestriction.name:
-                return (await Promise.resolve().then(function () { return healthRestriction_entity; })).healthRestrictionFactory();
-            case RootConfig.entities.healthRecordType.name:
-                return (await Promise.resolve().then(function () { return healthRecordType_entity; })).healthRecordTypeFactory();
-            case RootConfig.entities.healthEvent.name:
-                return (await Promise.resolve().then(function () { return healthEvent_entity; })).healthEventFactory();
-            case RootConfig.entities.healthProfile.name:
-                return (await Promise.resolve().then(function () { return healthProfile_entity; })).healthProfileFactory();
-            case RootConfig.entities.healthCondition.name:
-                return (await Promise.resolve().then(function () { return healthCondition_entity; })).healthConditionFactory();
+                return (await import('./acorex-modules-health-core-vaccination-type.entity-DlQ4MQVm.mjs')).vaccinationTypeFactory();
         }
         return null;
     }
@@ -2625,6 +381,29 @@ var entity_provider = /*#__PURE__*/Object.freeze({
     AXMHealthCoreEntityProvider: AXMHealthCoreEntityProvider
 });
 
+const AXMHealthCoreMenuKeys = {
+    Root: 'health-core',
+    AllergyTypes: 'health-core.allergy-types',
+    BloodTypes: 'health-core.blood-types',
+    BodyParts: 'health-core.body-parts',
+    ChronicConditionTypes: 'health-core.chronic-condition-types',
+    DisabilityStatuses: 'health-core.disability-statuses',
+    InjuryTypes: 'health-core.injury-types',
+    VaccinationTypes: 'health-core.vaccination-types',
+};
+
+const AXMHealthCorePermissionKeys = {
+    HealthCore: {
+        AllergyType: { Management: 'HealthCore:Permission:AllergyType.Management' },
+        BloodType: { Management: 'HealthCore:Permission:BloodType.Management' },
+        BodyPart: { Management: 'HealthCore:Permission:BodyPart.Management' },
+        ChronicConditionType: { Management: 'HealthCore:Permission:ChronicConditionType.Management' },
+        DisabilityStatus: { Management: 'HealthCore:Permission:DisabilityStatus.Management' },
+        InjuryType: { Management: 'HealthCore:Permission:InjuryType.Management' },
+        VaccinationType: { Management: 'HealthCore:Permission:VaccinationType.Management' },
+    },
+};
+
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Menu Provider   ----
@@ -2634,85 +413,16 @@ class AXMHealthCoreMenuProvider {
     }
     async provide(context) {
         const module = RootConfig.module;
-        const keys = AXMHealthCorePermissionKeys.HealthCore;
-        const healthMenu = context.find(AXPCommonMenuKeys.Health);
-        if (!healthMenu.exists) {
-            context.find(AXPCommonMenuKeys.Configuration).addItems([
-                {
-                    name: AXPCommonMenuKeys.Health,
-                    priority: 8445,
-                    text: '@general:menus.health.title',
-                    icon: 'fa-light fa-heart-pulse',
-                    type: 'menu',
-                    children: [],
-                },
-            ]);
-        }
-        context.find(AXPCommonMenuKeys.Health).addItems([
-            {
-                name: AXMHealthCoreMenuKeys.BloodTypes,
-                text: RootConfig.entities.bloodType.titlePlural,
-                icon: RootConfig.entities.bloodType.icon,
-                priority: 11,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.bloodType.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.BloodType.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.BodyParts,
-                text: RootConfig.entities.bodyPart.titlePlural,
-                icon: RootConfig.entities.bodyPart.icon,
-                priority: 12,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.bodyPart.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.BodyPart.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.DisabilityStatuses,
-                text: RootConfig.entities.disabilityStatus.titlePlural,
-                icon: RootConfig.entities.disabilityStatus.icon,
-                priority: 14,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.disabilityStatus.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.DisabilityStatus.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.InjuryTypes,
-                text: RootConfig.entities.injuryType.titlePlural,
-                icon: RootConfig.entities.injuryType.icon,
-                priority: 15,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.injuryType.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.InjuryType.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.VaccinationTypes,
-                text: RootConfig.entities.vaccinationType.titlePlural,
-                icon: RootConfig.entities.vaccinationType.icon,
-                priority: 16,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.vaccinationType.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.VaccinationType.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.HealthConditionTypes,
-                text: RootConfig.entities.healthConditionType.titlePlural,
-                icon: RootConfig.entities.healthConditionType.icon,
-                priority: 17,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.healthConditionType.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.HealthConditionType.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.HealthRestrictions,
-                text: RootConfig.entities.healthRestriction.titlePlural,
-                icon: RootConfig.entities.healthRestriction.icon,
-                priority: 18,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.healthRestriction.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.HealthRestriction.Management] },
-            },
-            {
-                name: AXMHealthCoreMenuKeys.HealthRecordTypes,
-                text: RootConfig.entities.healthRecordType.titlePlural,
-                icon: RootConfig.entities.healthRecordType.icon,
-                priority: 19,
-                path: this.entityService.withEntity(module.name, RootConfig.entities.healthRecordType.name).createPath(),
-                policy: { features: [RootConfig.module.name], permissions: [keys.HealthRecordType.Management] },
-            },
+        // Health group under Configuration/People and Demographics (with divider before)
+        context.find(AXPCommonMenuKeys.PeopleAndDemographics).addItems([
+            { name: `${AXMHealthCoreMenuKeys.Root}:divider`, text: '', type: 'break', priority: 8 },
+            { name: AXMHealthCoreMenuKeys.AllergyTypes, text: RootConfig.entities.allergyType.titlePlural, icon: RootConfig.entities.allergyType.icon, priority: 10, path: this.entityService.withEntity(module.name, RootConfig.entities.allergyType.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.AllergyType.Management] } },
+            { name: AXMHealthCoreMenuKeys.BloodTypes, text: RootConfig.entities.bloodType.titlePlural, icon: RootConfig.entities.bloodType.icon, priority: 11, path: this.entityService.withEntity(module.name, RootConfig.entities.bloodType.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.BloodType.Management] } },
+            { name: AXMHealthCoreMenuKeys.BodyParts, text: RootConfig.entities.bodyPart.titlePlural, icon: RootConfig.entities.bodyPart.icon, priority: 12, path: this.entityService.withEntity(module.name, RootConfig.entities.bodyPart.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.BodyPart.Management] } },
+            { name: AXMHealthCoreMenuKeys.ChronicConditionTypes, text: RootConfig.entities.chronicConditionType.titlePlural, icon: RootConfig.entities.chronicConditionType.icon, priority: 13, path: this.entityService.withEntity(module.name, RootConfig.entities.chronicConditionType.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.ChronicConditionType.Management] } },
+            { name: AXMHealthCoreMenuKeys.DisabilityStatuses, text: RootConfig.entities.disabilityStatus.titlePlural, icon: RootConfig.entities.disabilityStatus.icon, priority: 14, path: this.entityService.withEntity(module.name, RootConfig.entities.disabilityStatus.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.DisabilityStatus.Management] } },
+            { name: AXMHealthCoreMenuKeys.InjuryTypes, text: RootConfig.entities.injuryType.titlePlural, icon: RootConfig.entities.injuryType.icon, priority: 15, path: this.entityService.withEntity(module.name, RootConfig.entities.injuryType.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.InjuryType.Management] } },
+            { name: AXMHealthCoreMenuKeys.VaccinationTypes, text: RootConfig.entities.vaccinationType.titlePlural, icon: RootConfig.entities.vaccinationType.icon, priority: 16, path: this.entityService.withEntity(module.name, RootConfig.entities.vaccinationType.name).createPath(), policy: { features: [RootConfig.module.name], permissions: [AXMHealthCorePermissionKeys.HealthCore.VaccinationType.Management] } },
         ]);
     }
 }
@@ -2732,57 +442,29 @@ class AXMHealthCorePermissionDefinitionProvider {
     }
     async define(context) {
         const keys = AXMHealthCorePermissionKeys.HealthCore;
+        const allergyTypeTrans = (action) => this.translationService.translateAsync(`@health-core:allergy-types.permissions.allergy-type.${action}.title`);
         const bloodTypeTrans = (action) => this.translationService.translateAsync(`@health-core:blood-types.permissions.blood-type.${action}.title`);
         const bodyPartTrans = (action) => this.translationService.translateAsync(`@health-core:body-parts.permissions.body-part.${action}.title`);
+        const chronicConditionTypeTrans = (action) => this.translationService.translateAsync(`@health-core:chronic-condition-types.permissions.chronic-condition-type.${action}.title`);
         const disabilityStatusTrans = (action) => this.translationService.translateAsync(`@health-core:disability-statuses.permissions.disability-status.${action}.title`);
         const injuryTypeTrans = (action) => this.translationService.translateAsync(`@health-core:injury-types.permissions.injury-type.${action}.title`);
         const vaccinationTypeTrans = (action) => this.translationService.translateAsync(`@health-core:vaccination-types.permissions.vaccination-type.${action}.title`);
-        const healthConditionTypeTrans = (action) => this.translationService.translateAsync(`@health-core:health-condition-types.permissions.health-condition-type.${action}.title`);
-        const healthRestrictionTrans = (action) => this.translationService.translateAsync(`@health-core:health-restrictions.permissions.health-restriction.${action}.title`);
-        const healthRecordTypeTrans = (action) => this.translationService.translateAsync(`@health-core:health-record-types.permissions.health-record-type.${action}.title`);
-        const healthRecordTrans = (entity, action) => this.translationService.translateAsync(`@health-core:${entity}.permissions.${entity}.${action}.title`);
         context
             .addGroup(RootConfig.module.name, await this.translationService.translateAsync('@health-core:module.title'))
+            .addPermission(keys.AllergyType.Management, await allergyTypeTrans('manage'))
+            .endPermission()
             .addPermission(keys.BloodType.Management, await bloodTypeTrans('manage'))
             .endPermission()
             .addPermission(keys.BodyPart.Management, await bodyPartTrans('manage'))
             .endPermission()
+            .addPermission(keys.ChronicConditionType.Management, await chronicConditionTypeTrans('manage'))
+            .endPermission()
             .addPermission(keys.DisabilityStatus.Management, await disabilityStatusTrans('manage'))
             .endPermission()
             .addPermission(keys.InjuryType.Management, await injuryTypeTrans('manage'))
             .endPermission()
             .addPermission(keys.VaccinationType.Management, await vaccinationTypeTrans('manage'))
             .endPermission()
-            .addPermission(keys.HealthConditionType.Management, await healthConditionTypeTrans('manage'))
-            .endPermission()
-            .addPermission(keys.HealthRestriction.Management, await healthRestrictionTrans('manage'))
-            .endPermission()
-            .addPermission(keys.HealthRecordType.Management, await healthRecordTypeTrans('manage'))
-            .endPermission()
-            .addPermission(keys.HealthProfile.ViewOwn, await healthRecordTrans('health-profiles', 'view-own'))
-            .endPermission()
-            .addPermission(keys.HealthProfile.EditOwn, await healthRecordTrans('health-profiles', 'edit-own'))
-            .endPermission()
-            .addPermission(keys.HealthProfile.View, await healthRecordTrans('health-profiles', 'view'))
-            .endPermission()
-            .addPermission(keys.HealthProfile.Manage, await healthRecordTrans('health-profiles', 'manage'))
-            .endPermission()
-            .addPermission(keys.HealthCondition.ViewOwn, await healthRecordTrans('health-conditions', 'view-own'))
-            .endPermission()
-            .addPermission(keys.HealthCondition.EditOwn, await healthRecordTrans('health-conditions', 'edit-own'))
-            .endPermission()
-            .addPermission(keys.HealthCondition.View, await healthRecordTrans('health-conditions', 'view'))
-            .endPermission()
-            .addPermission(keys.HealthCondition.Manage, await healthRecordTrans('health-conditions', 'manage'))
-            .endPermission()
-            .addPermission(keys.HealthEvent.ViewOwn, await healthRecordTrans('health-events', 'view-own'))
-            .endPermission()
-            .addPermission(keys.HealthEvent.EditOwn, await healthRecordTrans('health-events', 'edit-own'))
-            .endPermission()
-            .addPermission(keys.HealthEvent.View, await healthRecordTrans('health-events', 'view'))
-            .endPermission()
-            .addPermission(keys.HealthEvent.Manage, await healthRecordTrans('health-events', 'manage'))
-            .endPermission()
             .endGroup();
     }
 }
@@ -2793,11 +475,14 @@ var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
     AXMHealthCorePermissionDefinitionProvider: AXMHealthCorePermissionDefinitionProvider
 });
 
+//#region ---- Contracts barrel ----
+//#endregion
+
 // Main Module
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMHealthCoreCommandKeys, AXMHealthCoreDataSourceKeys, AXMHealthCoreEntityProvider, AXMHealthCoreMenuKeys, AXMHealthCoreMenuProvider, AXMHealthCoreModule, AXMHealthCorePermissionDefinitionProvider, AXMHealthCorePermissionKeys, HEALTH_CATALOG_SCOPE, HEALTH_PERSON_SUBJECT_TYPE, HEALTH_SUBJECT_PROPERTY_NAMES, RootConfig, bloodTypeFactory, bodyPartFactory, createHealthSubjectLookupProperty, disabilityStatusFactory, healthConditionFactory, healthConditionTypeFactory, healthEventFactory, healthPersonSubjectReferenceConditions, healthProfileFactory, healthRecordTypeFactory, healthRestrictionFactory, healthSubjectReferenceConditions, injuryTypeFactory, omitHealthSubjectFromEditLayouts, vaccinationTypeFactory };
+export { AXMHealthCoreDataSourceKeys, AXMHealthCoreEntityProvider, AXMHealthCoreMenuKeys, AXMHealthCoreMenuProvider, AXMHealthCoreModule, AXMHealthCorePermissionDefinitionProvider, AXMHealthCorePermissionKeys, RootConfig };
 //# sourceMappingURL=acorex-modules-health-core.mjs.map