import * as i0 from '@angular/core';
import { Injectable, inject, Injector, NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { AXPSystemActionType, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER } from '@acorex/platform/core';
import { AXPEntityService, AXMEntityCrudServiceImpl, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
import { AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
import { AXPCommonMenuKeys } from '@acorex/modules/common';
import { AXTranslationService } from '@acorex/core/translation';
import { RootConfig as RootConfig$1 } from '@acorex/modules/person-core';
import { AXDataSource } from '@acorex/cdk/common';
import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';

const config = {
    i18n: 'person-management',
};
const RootConfig = {
    config,
    module: {
        name: 'PersonManagement',
        title: '@person-management:module.title',
        icon: 'fa-light fa-user',
    },
    entities: {
        person: {
            name: 'Person',
            title: '@person-management:person.individual-title',
            fullname: 'PersonManagement.Person',
            titlePlural: '@person-management:person.plural-title',
            icon: 'fa-light fa-user',
        },
        personRole: {
            name: 'PersonRole',
            title: '@person-management:person-role.individual-title',
            titlePlural: '@person-management:person-role.plural-title',
            icon: 'fa-light fa-user-tag',
        },
        personRelationship: {
            name: 'PersonRelationship',
            title: '@person-management:person-relationship.individual-title',
            titlePlural: '@person-management:person-relationship.plural-title',
            icon: 'fa-light fa-link',
        },
        personIdentifier: {
            name: 'PersonIdentifier',
            title: '@person-management:person-identifier.individual-title',
            titlePlural: '@person-management:person-identifier.plural-title',
            icon: 'fa-light fa-fingerprint',
        },
    },
};

//#region ----   Imports   ----
//#endregion
//#region ----   Manifest Definition   ----
/**
 * Person Management Module Manifest.
 * Defines module metadata, features, and provider references.
 */
const PersonManagementManifest = {
    name: RootConfig.module.name,
    version: '1.0.0',
    title: RootConfig.module.title,
    icon: RootConfig.module.icon,
    i18n: RootConfig.config.i18n,
    // Module dependencies
    dependencies: ['LocationManagement'],
};
//#endregion

//#region ----   Imports   ----
//#endregion
//#region ----   Permission Keys   ----
const moduleKey = RootConfig.module.name;
const entitiesKey = RootConfig.entities;
const manageKey = AXPSystemActionType.Manage;
const viewKey = AXPSystemActionType.View;
const updateKey = AXPSystemActionType.Update;
const deleteKey = AXPSystemActionType.Delete;
const createKey = AXPSystemActionType.Create;
const AXMPermissionsKeys = {
    PersonManagement: {
        Management: `${moduleKey}:${manageKey}`,
        Person: {
            Management: `${moduleKey}:${entitiesKey.person.name}:${manageKey}`,
            View: `${moduleKey}:${entitiesKey.person.name}:${viewKey}`,
            Create: `${moduleKey}:${entitiesKey.person.name}:${createKey}`,
            Update: `${moduleKey}:${entitiesKey.person.name}:${updateKey}`,
            Delete: `${moduleKey}:${entitiesKey.person.name}:${deleteKey}`,
        },
        PersonRole: {
            Management: `${moduleKey}:${entitiesKey.personRole.name}:${manageKey}`,
            View: `${moduleKey}:${entitiesKey.personRole.name}:${viewKey}`,
            Create: `${moduleKey}:${entitiesKey.personRole.name}:${createKey}`,
            Update: `${moduleKey}:${entitiesKey.personRole.name}:${updateKey}`,
            Delete: `${moduleKey}:${entitiesKey.personRole.name}:${deleteKey}`,
        },
        PersonRelationship: {
            Management: `${moduleKey}:${entitiesKey.personRelationship.name}:${manageKey}`,
            View: `${moduleKey}:${entitiesKey.personRelationship.name}:${viewKey}`,
            Create: `${moduleKey}:${entitiesKey.personRelationship.name}:${createKey}`,
            Update: `${moduleKey}:${entitiesKey.personRelationship.name}:${updateKey}`,
            Delete: `${moduleKey}:${entitiesKey.personRelationship.name}:${deleteKey}`,
        },
        PersonIdentifier: {
            Management: `${moduleKey}:${entitiesKey.personIdentifier.name}:${manageKey}`,
            View: `${moduleKey}:${entitiesKey.personIdentifier.name}:${viewKey}`,
            Create: `${moduleKey}:${entitiesKey.personIdentifier.name}:${createKey}`,
            Update: `${moduleKey}:${entitiesKey.personIdentifier.name}:${updateKey}`,
            Delete: `${moduleKey}:${entitiesKey.personIdentifier.name}:${deleteKey}`,
        },
    },
};
//#endregion

//#endregion
//#region ----   Permission Definition Provider   ----
class AXMPermissionDefinitionProvider {
    //#region ----   Define Method   ----
    async define(context) {
        const keys = AXMPermissionsKeys.PersonManagement;
        // I18n path constants
        const MODULE = '@person-management:module';
        const PERSON_PERMISSIONS = '@person-management:person.permissions.persons';
        context
            .addGroup(RootConfig.module.name, `${MODULE}.title`, `${MODULE}.description`)
            //
            .addPermission(keys.Person.Management, `${PERSON_PERMISSIONS}.title`, `${PERSON_PERMISSIONS}.description`)
            .addChild(keys.Person.View, `${PERSON_PERMISSIONS}.actions.view.title`, `${PERSON_PERMISSIONS}.actions.view.description`)
            .addChild(keys.Person.Create, `${PERSON_PERMISSIONS}.actions.create.title`, `${PERSON_PERMISSIONS}.actions.create.description`)
            .addChild(keys.Person.Update, `${PERSON_PERMISSIONS}.actions.edit.title`, `${PERSON_PERMISSIONS}.actions.edit.description`)
            .addChild(keys.Person.Delete, `${PERSON_PERMISSIONS}.actions.delete.title`, `${PERSON_PERMISSIONS}.actions.delete.description`)
            .endPermission()
            //
            .endGroup();
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPermissionDefinitionProvider }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPermissionDefinitionProvider, decorators: [{
            type: Injectable
        }] });

const AXPPersonManagementMenuKeys = {
    Root: 'person-management:menu:root',
    Persons: 'person-management:menu:persons',
};

//#region ----   Imports   ----
//#endregion
//#region ----   Menu Provider   ----
class AXMMenuProvider {
    constructor() {
        this.entityService = inject(AXPEntityService);
    }
    async provide(context) {
        const module = RootConfig.module;
        // Add Persons under Contacts menu
        context.find(AXPCommonMenuKeys.Contacts).addItems([
            {
                name: AXPPersonManagementMenuKeys.Persons,
                text: '@person-management:person.plural-title',
                path: this.entityService.createPath(module.name, RootConfig.entities.person.name),
                icon: RootConfig.entities.person.icon,
                priority: 2,
                policy: {
                    permissions: [AXMPermissionsKeys.PersonManagement.Person.View],
                },
            },
        ]);
    }
}
//#endregion

class AXMPersonManagementEntityProvider {
    constructor() {
        this.injector = inject(Injector);
    }
    preload() {
        const module = RootConfig.module.name;
        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
            module: module,
            entity: entity.name,
        }));
    }
    async get(moduleName, entityName) {
        if (moduleName == RootConfig.module.name) {
            switch (entityName) {
                case RootConfig.entities.person.name:
                    return (await import('./acorex-modules-person-management-person.entity-CaEVw1mL.mjs')).personFactory(this.injector);
                case RootConfig.entities.personRole.name:
                    return (await import('./acorex-modules-person-management-person-role.entity-C6aEm6oN.mjs')).personRoleFactory(this.injector);
                case RootConfig.entities.personRelationship.name:
                    return (await import('./acorex-modules-person-management-person-relationship.entity-DbcXasEe.mjs')).personRelationshipFactory(this.injector);
                case RootConfig.entities.personIdentifier.name:
                    return (await import('./acorex-modules-person-management-person-identifier.entity-HBmiUahC.mjs')).personIdentifierFactory(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 })));
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementEntityProvider }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementEntityProvider, decorators: [{
            type: Injectable
        }] });

class AXMSettingProvider {
    constructor(injector) {
        this.injector = injector;
        this.translateService = this.injector.get(AXTranslationService);
    }
    async provide(context) {
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMSettingProvider }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMSettingProvider, decorators: [{
            type: Injectable
        }], ctorParameters: () => [{ type: i0.Injector }] });

class AXMSearchCommandProvider extends AXPSearchCommandProvider {
    constructor() {
        super(...arguments);
        this.commands = [
            {
                group: 'command',
                title: 'New Person',
                icon: RootConfig.entities.person.icon,
                description: 'Create a new person.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig.module.name}.${RootConfig.entities.person.name}`,
                    },
                },
            },
            {
                group: 'command',
                title: 'New Person Role',
                icon: RootConfig.entities.personRole.icon,
                description: 'Assign a role to a person.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig.module.name}.${RootConfig.entities.personRole.name}`,
                    },
                },
            },
            {
                group: 'command',
                title: 'New Person Relationship',
                icon: RootConfig.entities.personRelationship.icon,
                description: 'Create a relationship between two persons.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig.module.name}.${RootConfig.entities.personRelationship.name}`,
                    },
                },
            },
            {
                group: 'command',
                title: 'New Person Relationship Type',
                icon: RootConfig$1.entities.personRelationshipType.icon,
                description: 'Define a new type of person relationship.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig$1.module.name}.${RootConfig$1.entities.personRelationshipType.name}`,
                    },
                },
            },
            {
                group: 'command',
                title: 'New Person Identifier Type',
                icon: RootConfig$1.entities.personIdentifierType.icon,
                description: 'Create a new type of person identifier.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig$1.module.name}.${RootConfig$1.entities.personIdentifierType.name}`,
                    },
                },
            },
            {
                group: 'command',
                title: 'New Person Identifier',
                icon: RootConfig.entities.personIdentifier.icon,
                description: 'Add an identifier to a person.',
                command: {
                    name: 'create-entity',
                    options: {
                        entity: `${RootConfig.module.name}.${RootConfig.entities.personIdentifier.name}`,
                    },
                },
            },
        ];
    }
}

//#region ----   Imports   ----
//#endregion
//#region ----   Feature Definition Provider   ----
/**
 * Person Management Feature Definition Provider.
 * Provides feature definitions for the Person Management module.
 */
class AXMPersonManagementFeatureDefinitionProvider {
    async provide(context) {
        // Management feature removed - module name is used directly as feature key
    }
}
//#endregion

class AXMPersonRoleTypesDataSourceDefinition {
    constructor() {
        this.translate = inject(AXTranslationService);
    }
    async items() {
        const list = [
            { id: 'customer', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.customer') },
            { id: 'vendor', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.vendor') },
            { id: 'subcontractor', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.subcontractor') },
            { id: 'client', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.client') },
            { id: 'employee', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.employee') },
            { id: 'partner', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.partner') },
            { id: 'supplier', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.supplier') },
            { id: 'member', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.member') },
            { id: 'other', title: await this.translate.translateAsync('@person-management:person-role.properties.role.options.other') },
        ];
        return Promise.resolve([
            {
                name: 'person-role-types',
                title: 'Person Role Types',
                source: () => {
                    return new AXDataSource({
                        key: 'id',
                        load: async (_) => {
                            return {
                                items: list,
                                total: list.length,
                            };
                        },
                        byKey: async (key) => {
                            return list.find((item) => item.id === key);
                        },
                        pageSize: 20,
                    });
                },
                columns: [
                    {
                        name: 'id',
                        title: 'ID',
                        datatype: 'uuid',
                        type: AXPWidgetsCatalog.text,
                    },
                    {
                        name: 'title',
                        title: `Title`,
                        datatype: 'string',
                        type: AXPWidgetsCatalog.text,
                    },
                ],
                filters: [
                    {
                        field: 'title',
                        title: 'Title',
                        operator: {
                            type: 'equal',
                        },
                        widget: {
                            type: AXPWidgetsCatalog.text,
                        },
                        filterType: {
                            advance: true,
                            inline: true,
                        },
                    },
                ],
                textField: {
                    name: 'title',
                    title: 'Title',
                },
                valueField: {
                    name: 'id',
                    title: 'ID',
                },
            },
        ]);
    }
}

//#region ----   Imports   ----
//#endregion
//#region ----   Data Source Provider   ----
/**
 * Person Management Data Source Provider.
 * Provides all datasource definitions for the Person Management module.
 */
class AXMPersonManagementDataSourceProvider {
    constructor() {
        this.personRoleTypes = new AXMPersonRoleTypesDataSourceDefinition();
    }
    async items() {
        const items = await Promise.all([
            this.personRoleTypes.items(),
        ]);
        return items.flat();
    }
}
//#endregion

class AXMPersonService extends AXMEntityCrudServiceImpl {
}
class AXMPersonServiceImpl extends AXMPersonService {
    constructor() {
        super(`${RootConfig.module.name}.${RootConfig.entities.person.name}`);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonServiceImpl }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonServiceImpl, decorators: [{
            type: Injectable
        }], ctorParameters: () => [] });

class AXMPersonRoleService extends AXMEntityCrudServiceImpl {
}
class AXMPersonRoleServiceImpl extends AXMPersonRoleService {
    constructor() {
        super(`${RootConfig.module.name}.${RootConfig.entities.personRole.name}`);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleServiceImpl }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleServiceImpl, decorators: [{
            type: Injectable
        }], ctorParameters: () => [] });

class AXMPersonRelationshipService extends AXMEntityCrudServiceImpl {
}
class AXMPersonRelationshipServiceImpl extends AXMPersonRelationshipService {
    constructor() {
        super(`${RootConfig.module.name}.${RootConfig.entities.personRelationship.name}`);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipServiceImpl }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipServiceImpl, decorators: [{
            type: Injectable
        }], ctorParameters: () => [] });

class AXMPersonIdentifierService extends AXMEntityCrudServiceImpl {
}
class AXMPersonIdentifierServiceImpl extends AXMPersonIdentifierService {
    constructor() {
        super(`${RootConfig.module.name}.${RootConfig.entities.personIdentifier.name}`);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierServiceImpl }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierServiceImpl, decorators: [{
            type: Injectable
        }], ctorParameters: () => [] });

class AXMPersonEntityModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonEntityModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonEntityModule, providers: [
            {
                provide: AXMPersonService,
                useClass: AXMPersonServiceImpl,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonEntityModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [],
                    exports: [],
                    declarations: [],
                    providers: [
                        {
                            provide: AXMPersonService,
                            useClass: AXMPersonServiceImpl,
                        },
                    ],
                }]
        }] });

class AXMPersonRoleEntityModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleEntityModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleEntityModule, providers: [
            {
                provide: AXMPersonRoleService,
                useClass: AXMPersonRoleServiceImpl,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRoleEntityModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [],
                    exports: [],
                    declarations: [],
                    providers: [
                        {
                            provide: AXMPersonRoleService,
                            useClass: AXMPersonRoleServiceImpl,
                        },
                    ],
                }]
        }] });

class AXMPersonRelationshipEntityModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipEntityModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipEntityModule, providers: [
            {
                provide: AXMPersonRelationshipService,
                useClass: AXMPersonRelationshipServiceImpl,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonRelationshipEntityModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [],
                    exports: [],
                    declarations: [],
                    providers: [
                        {
                            provide: AXMPersonRelationshipService,
                            useClass: AXMPersonRelationshipServiceImpl,
                        },
                    ],
                }]
        }] });

class AXMPersonIdentifierEntityModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierEntityModule }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierEntityModule, providers: [
            {
                provide: AXMPersonIdentifierService,
                useClass: AXMPersonIdentifierServiceImpl,
            },
        ] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonIdentifierEntityModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [],
                    exports: [],
                    declarations: [],
                    providers: [
                        {
                            provide: AXMPersonIdentifierService,
                            useClass: AXMPersonIdentifierServiceImpl,
                        },
                    ],
                }]
        }] });

// Entity Services

class AXMPersonManagementModule {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementModule, imports: [CommonModule,
            // Entity Modules
            AXMPersonEntityModule,
            AXMPersonRoleEntityModule,
            AXMPersonRelationshipEntityModule,
            AXMPersonIdentifierEntityModule] }); }
    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementModule, providers: [
            // Module Manifest Provider
            {
                provide: AXP_MODULE_MANIFEST_PROVIDER,
                useValue: PersonManagementManifest,
                multi: true,
            },
            // Provider references (now using tokens)
            {
                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
                useClass: AXMPermissionDefinitionProvider,
                multi: true,
            },
            {
                provide: AXP_MENU_PROVIDER,
                useClass: AXMMenuProvider,
                multi: true,
            },
            {
                provide: AXP_ENTITY_DEFINITION_LOADER,
                useClass: AXMPersonManagementEntityProvider,
                multi: true,
            },
            {
                provide: AXP_SETTING_DEFINITION_PROVIDER,
                useClass: AXMSettingProvider,
                multi: true,
            },
            {
                provide: AXP_SEARCH_PROVIDER,
                useClass: AXMSearchCommandProvider,
                multi: true,
            },
            {
                provide: AXP_FEATURE_DEFINITION_PROVIDER,
                useClass: AXMPersonManagementFeatureDefinitionProvider,
                multi: true,
            },
            {
                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                useClass: AXMPersonManagementDataSourceProvider,
                multi: true,
            },
        ], imports: [CommonModule,
            // Entity Modules
            AXMPersonEntityModule,
            AXMPersonRoleEntityModule,
            AXMPersonRelationshipEntityModule,
            AXMPersonIdentifierEntityModule] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXMPersonManagementModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [
                        CommonModule,
                        // Entity Modules
                        AXMPersonEntityModule,
                        AXMPersonRoleEntityModule,
                        AXMPersonRelationshipEntityModule,
                        AXMPersonIdentifierEntityModule,
                    ],
                    providers: [
                        // Module Manifest Provider
                        {
                            provide: AXP_MODULE_MANIFEST_PROVIDER,
                            useValue: PersonManagementManifest,
                            multi: true,
                        },
                        // Provider references (now using tokens)
                        {
                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
                            useClass: AXMPermissionDefinitionProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_MENU_PROVIDER,
                            useClass: AXMMenuProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_ENTITY_DEFINITION_LOADER,
                            useClass: AXMPersonManagementEntityProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_SETTING_DEFINITION_PROVIDER,
                            useClass: AXMSettingProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_SEARCH_PROVIDER,
                            useClass: AXMSearchCommandProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
                            useClass: AXMPersonManagementFeatureDefinitionProvider,
                            multi: true,
                        },
                        {
                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
                            useClass: AXMPersonManagementDataSourceProvider,
                            multi: true,
                        },
                    ],
                }]
        }] });

//export * from './lib/pages';

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

export { AXMMenuProvider, AXMPersonManagementEntityProvider, AXMPersonManagementModule, AXMSearchCommandProvider, AXMSettingProvider, RootConfig };
//# sourceMappingURL=acorex-modules-person-management.mjs.map
