import * as i0 from '@angular/core';
import { NgModule, inject, Injector } from '@angular/core';
import { AXP_MODULE_MANIFEST_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
import { AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
import { AXP_MENU_PROVIDER } from '@acorex/platform/common';
import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
import { AXDataSource } from '@acorex/cdk/common';
import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
import { AXPCommonMenuKeys } from '@acorex/modules/common';
import { AXTranslationService } from '@acorex/core/translation';

const config = {
    i18n: 'health-core',
    module: 'HealthCore',
};
const RootConfig = {
    config,
    module: {
        name: config.module,
        title: `@${config.i18n}:module.title`,
        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`,
            titlePlural: `@${config.i18n}:blood-types.entities.blood-type.plural`,
            icon: 'fa-light fa-droplet',
        },
        bodyPart: {
            name: 'BodyPart',
            title: `@${config.i18n}:body-parts.entities.body-part.title`,
            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`,
            titlePlural: `@${config.i18n}:disability-statuses.entities.disability-status.plural`,
            icon: 'fa-light fa-wheelchair',
        },
        injuryType: {
            name: 'InjuryType',
            title: `@${config.i18n}:injury-types.entities.injury-type.title`,
            titlePlural: `@${config.i18n}:injury-types.entities.injury-type.plural`,
            icon: 'fa-light fa-bandage',
        },
        vaccinationType: {
            name: 'VaccinationType',
            title: `@${config.i18n}:vaccination-types.entities.vaccination-type.title`,
            titlePlural: `@${config.i18n}:vaccination-types.entities.vaccination-type.plural`,
            icon: 'fa-light fa-syringe',
        },
    },
};

//#region ----   Imports   ----
//#endregion
//#region ----   Manifest Definition   ----
/**
 * Health Core Module Manifest.
 * Defines module metadata for health-related reference data (blood type, disability status, etc.).
 */
const HealthCoreManifest = {
    name: RootConfig.module.name,
    version: '1.0.0',
    title: RootConfig.module.title,
    icon: RootConfig.module.icon,
    i18n: RootConfig.config.i18n,
};
//#endregion

/**
 * Medication form options datasource (Tablet, Capsule, Syrup, Injection, etc.).
 */
class AXMMedicationFormOptionsDataSourceDefinition {
    constructor() {
        this.definition = {
            name: 'medication-form-options',
            title: '@health-core:datasources.medication-form-options.title',
            columns: [
                { name: 'value', title: '@health-core:datasources.medication-form-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
                { name: 'title', title: '@health-core:datasources.medication-form-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
            ],
            filters: [],
            textField: { name: 'title', title: '@health-core:datasources.medication-form-options.columns.title.title' },
            valueField: { name: 'value', title: '@health-core:datasources.medication-form-options.columns.value.title' },
            samples: [
                { value: 'tablet', title: '@health-core:datasources.medication-form-options.samples.tablet' },
                { value: 'capsule', title: '@health-core:datasources.medication-form-options.samples.capsule' },
                { value: 'syrup', title: '@health-core:datasources.medication-form-options.samples.syrup' },
                { value: 'injection', title: '@health-core:datasources.medication-form-options.samples.injection' },
                { value: 'cream', title: '@health-core:datasources.medication-form-options.samples.cream' },
                { value: 'drops', title: '@health-core:datasources.medication-form-options.samples.drops' },
                { value: 'inhaler', title: '@health-core:datasources.medication-form-options.samples.inhaler' },
                { value: 'patch', title: '@health-core:datasources.medication-form-options.samples.patch' },
                { value: 'other', title: '@health-core:datasources.medication-form-options.samples.other' },
            ],
            source: () => {
                const items = [
                    { value: 'tablet', title: '@health-core:datasources.medication-form-options.samples.tablet' },
                    { value: 'capsule', title: '@health-core:datasources.medication-form-options.samples.capsule' },
                    { value: 'syrup', title: '@health-core:datasources.medication-form-options.samples.syrup' },
                    { value: 'injection', title: '@health-core:datasources.medication-form-options.samples.injection' },
                    { value: 'cream', title: '@health-core:datasources.medication-form-options.samples.cream' },
                    { value: 'drops', title: '@health-core:datasources.medication-form-options.samples.drops' },
                    { value: 'inhaler', title: '@health-core:datasources.medication-form-options.samples.inhaler' },
                    { value: 'patch', title: '@health-core:datasources.medication-form-options.samples.patch' },
                    { value: 'other', title: '@health-core:datasources.medication-form-options.samples.other' },
                ];
                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];
    }
}

/**
 * Health risk level options datasource (Low, Medium, High, Critical).
 */
class AXMHealthRiskLevelOptionsDataSourceDefinition {
    constructor() {
        this.definition = {
            name: 'health-risk-level-options',
            title: '@health-core:datasources.health-risk-level-options.title',
            columns: [
                { name: 'value', title: '@health-core:datasources.health-risk-level-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
                { name: 'title', title: '@health-core:datasources.health-risk-level-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
            ],
            filters: [],
            textField: { name: 'title', title: '@health-core:datasources.health-risk-level-options.columns.title.title' },
            valueField: { name: 'value', title: '@health-core:datasources.health-risk-level-options.columns.value.title' },
            samples: [
                { value: 'low', title: '@health-core:datasources.health-risk-level-options.samples.low' },
                { value: 'medium', title: '@health-core:datasources.health-risk-level-options.samples.medium' },
                { value: 'high', title: '@health-core:datasources.health-risk-level-options.samples.high' },
                { value: 'critical', title: '@health-core:datasources.health-risk-level-options.samples.critical' },
            ],
            source: () => {
                const items = [
                    { value: 'low', title: '@health-core:datasources.health-risk-level-options.samples.low' },
                    { value: 'medium', title: '@health-core:datasources.health-risk-level-options.samples.medium' },
                    { value: 'high', title: '@health-core:datasources.health-risk-level-options.samples.high' },
                    { value: 'critical', title: '@health-core:datasources.health-risk-level-options.samples.critical' },
                ];
                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];
    }
}

/**
 * Alcohol consumption options datasource (Never, Occasional, Regular, etc.).
 */
class AXMAlcoholConsumptionOptionsDataSourceDefinition {
    constructor() {
        this.definition = {
            name: 'alcohol-consumption-options',
            title: '@health-core:datasources.alcohol-consumption-options.title',
            columns: [
                { name: 'value', title: '@health-core:datasources.alcohol-consumption-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
                { name: 'title', title: '@health-core:datasources.alcohol-consumption-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
            ],
            filters: [],
            textField: { name: 'title', title: '@health-core:datasources.alcohol-consumption-options.columns.title.title' },
            valueField: { name: 'value', title: '@health-core:datasources.alcohol-consumption-options.columns.value.title' },
            samples: [
                { value: 'never', title: '@health-core:datasources.alcohol-consumption-options.samples.never' },
                { value: 'occasional', title: '@health-core:datasources.alcohol-consumption-options.samples.occasional' },
                { value: 'regular', title: '@health-core:datasources.alcohol-consumption-options.samples.regular' },
                { value: 'heavy', title: '@health-core:datasources.alcohol-consumption-options.samples.heavy' },
                { value: 'prefer-not-to-say', title: '@health-core:datasources.alcohol-consumption-options.samples.prefer-not-to-say' },
            ],
            source: () => {
                const items = [
                    { value: 'never', title: '@health-core:datasources.alcohol-consumption-options.samples.never' },
                    { value: 'occasional', title: '@health-core:datasources.alcohol-consumption-options.samples.occasional' },
                    { value: 'regular', title: '@health-core:datasources.alcohol-consumption-options.samples.regular' },
                    { value: 'heavy', title: '@health-core:datasources.alcohol-consumption-options.samples.heavy' },
                    { value: 'prefer-not-to-say', title: '@health-core:datasources.alcohol-consumption-options.samples.prefer-not-to-say' },
                ];
                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];
    }
}

/**
 * Smoking status options datasource (Never, Former, Current, Prefer not to say).
 */
class AXMSmokingStatusOptionsDataSourceDefinition {
    constructor() {
        this.definition = {
            name: 'smoking-status-options',
            title: '@health-core:datasources.smoking-status-options.title',
            columns: [
                { name: 'value', title: '@health-core:datasources.smoking-status-options.columns.value.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
                { name: 'title', title: '@health-core:datasources.smoking-status-options.columns.title.title', type: AXPWidgetsCatalog.text, datatype: 'string' },
            ],
            filters: [],
            textField: { name: 'title', title: '@health-core:datasources.smoking-status-options.columns.title.title' },
            valueField: { name: 'value', title: '@health-core:datasources.smoking-status-options.columns.value.title' },
            samples: [
                { value: 'never', title: '@health-core:datasources.smoking-status-options.samples.never' },
                { value: 'former', title: '@health-core:datasources.smoking-status-options.samples.former' },
                { value: 'current', title: '@health-core:datasources.smoking-status-options.samples.current' },
                { value: 'prefer-not-to-say', title: '@health-core:datasources.smoking-status-options.samples.prefer-not-to-say' },
            ],
            source: () => {
                const items = [
                    { value: 'never', title: '@health-core:datasources.smoking-status-options.samples.never' },
                    { value: 'former', title: '@health-core:datasources.smoking-status-options.samples.former' },
                    { value: 'current', title: '@health-core:datasources.smoking-status-options.samples.current' },
                    { value: 'prefer-not-to-say', title: '@health-core:datasources.smoking-status-options.samples.prefer-not-to-say' },
                ];
                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];
    }
}

//#region ----   Imports   ----
//#endregion
//#region ----   Data Source Provider   ----
/**
 * Health Core Data Source Provider.
 * Provides health-related choice datasources (medication form, risk level, alcohol, smoking).
 */
class AXMHealthCoreDataSourceProvider {
    constructor() {
        this.medicationFormOptions = new AXMMedicationFormOptionsDataSourceDefinition();
        this.healthRiskLevelOptions = new AXMHealthRiskLevelOptionsDataSourceDefinition();
        this.alcoholConsumptionOptions = new AXMAlcoholConsumptionOptionsDataSourceDefinition();
        this.smokingStatusOptions = new AXMSmokingStatusOptionsDataSourceDefinition();
    }
    async items() {
        const items = await Promise.all([
            this.medicationFormOptions.items(),
            this.healthRiskLevelOptions.items(),
            this.alcoholConsumptionOptions.items(),
            this.smokingStatusOptions.items(),
        ]);
        return items.flat();
    }
}
//#endregion

//#region ----   Imports   ----
//#endregion
//#region ----   Module   ----
class AXMHealthCoreModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMHealthCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMHealthCoreModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMHealthCoreModule, providers: [
            {
                provide: AXP_MODULE_MANIFEST_PROVIDER,
                useValue: HealthCoreManifest,
                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)),
            {
                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                useClass: AXMHealthCoreDataSourceProvider,
                multi: true,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMHealthCoreModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [],
                    providers: [
                        {
                            provide: AXP_MODULE_MANIFEST_PROVIDER,
                            useValue: HealthCoreManifest,
                            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)),
                        {
                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                            useClass: AXMHealthCoreDataSourceProvider,
                            multi: true,
                        },
                    ],
                }]
        }] });

//#region ----   Allergy Type Model   ----
//#endregion

//#region ----   Blood Type Model   ----
//#endregion

//#region ----   Body Part Model   ----
//#endregion

//#region ----   Chronic Condition Type Model   ----
//#endregion

//#region ----   Disability Status Model   ----
//#endregion

//#region ----   Injury Type Model   ----
//#endregion

//#region ----   Vaccination Type Model   ----
//#endregion

//#region ----   Imports   ----
//#endregion
//#region ----   Entity Provider   ----
class AXMHealthCoreEntityProvider {
    constructor() {
        this.injector = inject(Injector);
    }
    async get(moduleName, entityName) {
        if (moduleName !== RootConfig.module.name) {
            return null;
        }
        switch (entityName) {
            case RootConfig.entities.allergyType.name:
                return (await import('./acorex-modules-health-core-allergy-type.entity-BaZ4OhHW.mjs')).allergyTypeFactory(this.injector);
            case RootConfig.entities.bloodType.name:
                return (await import('./acorex-modules-health-core-blood-type.entity-Cu-UIgw4.mjs')).bloodTypeFactory(this.injector);
            case RootConfig.entities.bodyPart.name:
                return (await import('./acorex-modules-health-core-body-part.entity-Dc2SIiB3.mjs')).bodyPartFactory(this.injector);
            case RootConfig.entities.chronicConditionType.name:
                return (await import('./acorex-modules-health-core-chronic-condition-type.entity-B-9j3pNB.mjs')).chronicConditionTypeFactory(this.injector);
            case RootConfig.entities.disabilityStatus.name:
                return (await import('./acorex-modules-health-core-disability-status.entity-hs3vA3zZ.mjs')).disabilityStatusFactory(this.injector);
            case RootConfig.entities.injuryType.name:
                return (await import('./acorex-modules-health-core-injury-type.entity-BUA1VsE_.mjs')).injuryTypeFactory(this.injector);
            case RootConfig.entities.vaccinationType.name:
                return (await import('./acorex-modules-health-core-vaccination-type.entity-DBdFkwx6.mjs')).vaccinationTypeFactory(this.injector);
        }
        return null;
    }
    async list() {
        const m = RootConfig.module.name;
        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
    }
}
//#endregion

var entity_provider = /*#__PURE__*/Object.freeze({
    __proto__: null,
    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   ----
class AXMHealthCoreMenuProvider {
    constructor() {
        this.entityService = inject(AXPEntityService);
    }
    async provide(context) {
        const module = RootConfig.module;
        context.find(AXPCommonMenuKeys.Configuration).addItems([
            {
                name: AXMHealthCoreMenuKeys.Root,
                priority: 8440,
                text: '@health-core:module.menus.root.title',
                icon: module.icon,
                policy: {
                    features: [RootConfig.module.name],
                },
                children: [
                    { name: AXMHealthCoreMenuKeys.AllergyTypes, text: RootConfig.entities.allergyType.titlePlural, icon: RootConfig.entities.allergyType.icon, priority: 1, path: this.entityService.withEntity(module.name, RootConfig.entities.allergyType.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.AllergyType.Management] } },
                    { name: AXMHealthCoreMenuKeys.BloodTypes, text: RootConfig.entities.bloodType.titlePlural, icon: RootConfig.entities.bloodType.icon, priority: 2, path: this.entityService.withEntity(module.name, RootConfig.entities.bloodType.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.BloodType.Management] } },
                    { name: AXMHealthCoreMenuKeys.BodyParts, text: RootConfig.entities.bodyPart.titlePlural, icon: RootConfig.entities.bodyPart.icon, priority: 3, path: this.entityService.withEntity(module.name, RootConfig.entities.bodyPart.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.BodyPart.Management] } },
                    { name: AXMHealthCoreMenuKeys.ChronicConditionTypes, text: RootConfig.entities.chronicConditionType.titlePlural, icon: RootConfig.entities.chronicConditionType.icon, priority: 4, path: this.entityService.withEntity(module.name, RootConfig.entities.chronicConditionType.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.ChronicConditionType.Management] } },
                    { name: AXMHealthCoreMenuKeys.DisabilityStatuses, text: RootConfig.entities.disabilityStatus.titlePlural, icon: RootConfig.entities.disabilityStatus.icon, priority: 5, path: this.entityService.withEntity(module.name, RootConfig.entities.disabilityStatus.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.DisabilityStatus.Management] } },
                    { name: AXMHealthCoreMenuKeys.InjuryTypes, text: RootConfig.entities.injuryType.titlePlural, icon: RootConfig.entities.injuryType.icon, priority: 6, path: this.entityService.withEntity(module.name, RootConfig.entities.injuryType.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.InjuryType.Management] } },
                    { name: AXMHealthCoreMenuKeys.VaccinationTypes, text: RootConfig.entities.vaccinationType.titlePlural, icon: RootConfig.entities.vaccinationType.icon, priority: 7, path: this.entityService.withEntity(module.name, RootConfig.entities.vaccinationType.name).createPath(), policy: { permissions: [AXMHealthCorePermissionKeys.HealthCore.VaccinationType.Management] } },
                ],
            },
        ]);
    }
}
//#endregion

var menu_provider = /*#__PURE__*/Object.freeze({
    __proto__: null,
    AXMHealthCoreMenuProvider: AXMHealthCoreMenuProvider
});

//#region ----   Imports   ----
//#endregion
//#region ----   Permission Definition Provider   ----
class AXMHealthCorePermissionDefinitionProvider {
    constructor() {
        this.translationService = inject(AXTranslationService);
    }
    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`);
        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()
            .endGroup();
    }
}
//#endregion

var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
    __proto__: null,
    AXMHealthCorePermissionDefinitionProvider: AXMHealthCorePermissionDefinitionProvider
});

// Main Module

/**
 * Generated bundle index. Do not edit.
 */

export { AXMHealthCoreEntityProvider, AXMHealthCoreMenuProvider, AXMHealthCoreModule, AXMHealthCorePermissionDefinitionProvider, AXMHealthCorePermissionKeys, RootConfig };
//# sourceMappingURL=acorex-modules-health-core.mjs.map
