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

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

@@ -1,13 +1,195 @@
 import * as i0 from '@angular/core';
-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 { 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 { 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';
-import { AXTranslationService } from '@acorex/core/translation';
+
+/** 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
 
 const config = {
     i18n: 'health-core',
@@ -21,12 +203,6 @@ 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`,
@@ -39,12 +215,6 @@ 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`,
@@ -63,9 +233,48 @@ 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   ----
@@ -82,16 +291,6 @@ 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.).
  */
@@ -252,12 +451,205 @@ 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).
+ * Provides health-related choice datasources (medication form, risk level, alcohol, smoking, workplace injury).
  */
 class AXMHealthCoreDataSourceProvider {
     constructor() {
@@ -265,6 +657,11 @@ 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([
@@ -272,24 +669,244 @@ 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 }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMHealthCoreModule, imports: [AXPRuntimeModule, AXMHealthCoreHealthEventFeatureModule] }); }
     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)),
@@ -298,18 +915,23 @@ 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: [],
+                    imports: [AXPRuntimeModule, AXMHealthCoreHealthEventFeatureModule],
                     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)),
@@ -322,25 +944,1639 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-//#region ----   Allergy Type Model   ----
 //#endregion
-
-//#region ----   Blood Type Model   ----
+//#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
 
-//#region ----   Body Part Model   ----
-//#endregion
+var bloodType_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    bloodTypeFactory: bloodTypeFactory
+});
 
-//#region ----   Chronic Condition Type Model   ----
 //#endregion
 
-//#region ----   Disability Status Model   ----
 //#endregion
-
-//#region ----   Injury Type Model   ----
+//#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;
+}
 //#endregion
 
-//#region ----   Vaccination Type Model   ----
+var bodyPart_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    bodyPartFactory: bodyPartFactory
+});
+
+//#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
+});
+
 //#endregion
 
 //#region ----   Imports   ----
@@ -352,20 +2588,28 @@ 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 import('./acorex-modules-health-core-blood-type.entity-165JDo8r.mjs')).bloodTypeFactory();
+                return (await Promise.resolve().then(function () { return bloodType_entity; })).bloodTypeFactory();
             case RootConfig.entities.bodyPart.name:
-                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();
+                return (await Promise.resolve().then(function () { return bodyPart_entity; })).bodyPartFactory();
             case RootConfig.entities.disabilityStatus.name:
-                return (await import('./acorex-modules-health-core-disability-status.entity-DN5reubi.mjs')).disabilityStatusFactory();
+                return (await Promise.resolve().then(function () { return disabilityStatus_entity; })).disabilityStatusFactory();
             case RootConfig.entities.injuryType.name:
-                return (await import('./acorex-modules-health-core-injury-type.entity-x9bs6Zly.mjs')).injuryTypeFactory();
+                return (await Promise.resolve().then(function () { return injuryType_entity; })).injuryTypeFactory();
             case RootConfig.entities.vaccinationType.name:
-                return (await import('./acorex-modules-health-core-vaccination-type.entity-DlQ4MQVm.mjs')).vaccinationTypeFactory();
+                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 null;
     }
@@ -381,29 +2625,6 @@ 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   ----
@@ -413,16 +2634,85 @@ class AXMHealthCoreMenuProvider {
     }
     async provide(context) {
         const module = RootConfig.module;
-        // 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] } },
+        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] },
+            },
         ]);
     }
 }
@@ -442,29 +2732,57 @@ 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();
     }
 }
@@ -475,14 +2793,11 @@ var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
     AXMHealthCorePermissionDefinitionProvider: AXMHealthCorePermissionDefinitionProvider
 });
 
-//#region ---- Contracts barrel ----
-//#endregion
-
 // Main Module
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMHealthCoreDataSourceKeys, AXMHealthCoreEntityProvider, AXMHealthCoreMenuKeys, AXMHealthCoreMenuProvider, AXMHealthCoreModule, AXMHealthCorePermissionDefinitionProvider, AXMHealthCorePermissionKeys, RootConfig };
+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 };
 //# sourceMappingURL=acorex-modules-health-core.mjs.map