import * as i0 from '@angular/core';
import { Injector } from '@angular/core';
import { AXPEntity, AXPMenuProvider, AXPMenuProviderContext, AXPSearchCommandProvider, AXPSearchResult, AXPSettingDefinitionProvider, AXPSettingDefinitionProviderContext } from '@acorex/platform/common';
import { AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader, AXPEntityPreloadEntity, AXPEntityModel, AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
import { AXPMetaDataDefinition } from '@acorex/platform/layout/widget-core';

declare class AXMTrainingManagementModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTrainingManagementModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTrainingManagementModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTrainingManagementModule>;
}

declare const RootConfig: {
    config: {
        i18n: string;
    };
    module: {
        module: string;
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        location: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        courseLocation: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        coursePeriod: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        period: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        trainingParticipant: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        facilitatorType: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        trainingFacilitator: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        trainingType: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        certificate: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        training: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        courseType: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        course: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
    };
};

declare class AXMEntityProvider implements AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader {
    private injector;
    preload(): AXPEntityPreloadEntity[];
    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMEntityProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMEntityProvider>;
}

declare class AXMMenuProvider implements AXPMenuProvider {
    private entityService;
    provide(context: AXPMenuProviderContext): Promise<void>;
}

declare class AXMSearchCommandProvider extends AXPSearchCommandProvider {
    commands: AXPSearchResult[];
}

declare class AXMSettingProvider implements AXPSettingDefinitionProvider {
    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
}

declare function courseFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementCourseEntityModel extends AXPEntityModel<string> {
    title: string;
    summary: string;
    units: number;
    courseTypeId: any;
    parentId: any;
}

declare abstract class AXMCourseService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementCourseEntityModel> {
}
declare class AXMCourseServiceImpl extends AXMCourseService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCourseServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCourseServiceImpl>;
}

declare function courseTypeFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementCourseTypeEntityModel extends AXPEntityModel<string> {
    title: string;
    parentId: any;
}

declare abstract class AXMCourseTypeService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementCourseTypeEntityModel> {
}
declare class AXMCourseTypeServiceImpl extends AXMCourseTypeService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCourseTypeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCourseTypeServiceImpl>;
}

declare function trainingFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementTrainingEntityModel extends AXPEntityModel<string> {
    title: string;
    description: string;
    courseId: any;
    periodId: any;
    trainingTypeId: any;
    certificateId: any;
    date: Date;
    expireDate: Date;
    status: string;
    isOnline: boolean;
}

declare abstract class AXMTrainingService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementTrainingEntityModel> {
}
declare class AXMTrainingServiceImpl extends AXMTrainingService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTrainingServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTrainingServiceImpl>;
}

declare function certificateFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementCertificateEntityModel extends AXPEntityModel<string> {
    title: string;
    description: string;
    issueDate: Date;
    expireDate: Date;
    certificateNumber: string;
    grade: string;
    score: number;
    status: string;
    trainingTypeId: any;
}

declare abstract class AXMCertificateService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementCertificateEntityModel> {
}
declare class AXMCertificateServiceImpl extends AXMCertificateService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCertificateServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCertificateServiceImpl>;
}

declare function trainingTypeFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementTrainingTypeEntityModel extends AXPEntityModel<string> {
    title: string;
    description: string;
    metaTags?: AXPMetaDataDefinition[];
}

declare abstract class AXMTrainingTypeService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementTrainingTypeEntityModel> {
}
declare class AXMTrainingTypeServiceImpl extends AXMTrainingTypeService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTrainingTypeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTrainingTypeServiceImpl>;
}

declare function trainingFacilitatorFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementTrainingFacilitatorEntityModel extends AXPEntityModel<string> {
    title: string;
    trainingId: any;
    personId: number;
    fcilitatorTypeId: any;
}

declare abstract class AXMTrainingFacilitatorService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementTrainingFacilitatorEntityModel> {
}
declare class AXMTrainingFacilitatorServiceImpl extends AXMTrainingFacilitatorService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTrainingFacilitatorServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTrainingFacilitatorServiceImpl>;
}

declare function facilitatorTypeFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementFacilitatorTypeEntityModel extends AXPEntityModel<string> {
    title: string;
    parentId: any;
    priority: number;
}

declare abstract class AXMFacilitatorTypeService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementFacilitatorTypeEntityModel> {
}
declare class AXMFacilitatorTypeServiceImpl extends AXMFacilitatorTypeService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMFacilitatorTypeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMFacilitatorTypeServiceImpl>;
}

declare function trainingParticipantFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementTrainingParticipantEntityModel extends AXPEntityModel<string> {
    title: string;
    trainingId: any;
    tarineeId: string;
    groupId: string;
}

declare abstract class AXMTrainingParticipantService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementTrainingParticipantEntityModel> {
}
declare class AXMTrainingParticipantServiceImpl extends AXMTrainingParticipantService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTrainingParticipantServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTrainingParticipantServiceImpl>;
}

declare function periodFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementPeriodEntityModel extends AXPEntityModel<string> {
    title: string;
    fromDate: Date;
    toDate: Date;
}

declare abstract class AXMPeriodService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementPeriodEntityModel> {
}
declare class AXMPeriodServiceImpl extends AXMPeriodService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMPeriodServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMPeriodServiceImpl>;
}

declare function coursePeriodFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementCoursePeriodEntityModel extends AXPEntityModel<string> {
    title: string;
    courseId: any;
    periodId: any;
}

declare abstract class AXMCoursePeriodService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementCoursePeriodEntityModel> {
}
declare class AXMCoursePeriodServiceImpl extends AXMCoursePeriodService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCoursePeriodServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCoursePeriodServiceImpl>;
}

declare function courseLocationFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementCourseLocationEntityModel extends AXPEntityModel<string> {
    title: string;
    courseId: any;
    locationId: any;
}

declare abstract class AXMCourseLocationService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementCourseLocationEntityModel> {
}
declare class AXMCourseLocationServiceImpl extends AXMCourseLocationService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCourseLocationServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCourseLocationServiceImpl>;
}

declare function locationFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTrainingManagementLocationEntityModel extends AXPEntityModel<string> {
    title: string;
    address: string;
    capacity: number;
    status: string;
}

declare abstract class AXMLocationService extends AXMEntityCrudServiceImpl<string, AXMTrainingManagementLocationEntityModel> {
}
declare class AXMLocationServiceImpl extends AXMLocationService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMLocationServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMLocationServiceImpl>;
}

export { AXMCertificateService, AXMCertificateServiceImpl, AXMCourseLocationService, AXMCourseLocationServiceImpl, AXMCoursePeriodService, AXMCoursePeriodServiceImpl, AXMCourseService, AXMCourseServiceImpl, AXMCourseTypeService, AXMCourseTypeServiceImpl, AXMEntityProvider, AXMFacilitatorTypeService, AXMFacilitatorTypeServiceImpl, AXMLocationService, AXMLocationServiceImpl, AXMMenuProvider, AXMPeriodService, AXMPeriodServiceImpl, AXMSearchCommandProvider, AXMSettingProvider, AXMTrainingFacilitatorService, AXMTrainingFacilitatorServiceImpl, AXMTrainingManagementModule, AXMTrainingParticipantService, AXMTrainingParticipantServiceImpl, AXMTrainingService, AXMTrainingServiceImpl, AXMTrainingTypeService, AXMTrainingTypeServiceImpl, RootConfig, certificateFactory, courseFactory, courseLocationFactory, coursePeriodFactory, courseTypeFactory, facilitatorTypeFactory, locationFactory, periodFactory, trainingFacilitatorFactory, trainingFactory, trainingParticipantFactory, trainingTypeFactory };
export type { AXMTrainingManagementCertificateEntityModel, AXMTrainingManagementCourseEntityModel, AXMTrainingManagementCourseLocationEntityModel, AXMTrainingManagementCoursePeriodEntityModel, AXMTrainingManagementCourseTypeEntityModel, AXMTrainingManagementFacilitatorTypeEntityModel, AXMTrainingManagementLocationEntityModel, AXMTrainingManagementPeriodEntityModel, AXMTrainingManagementTrainingEntityModel, AXMTrainingManagementTrainingFacilitatorEntityModel, AXMTrainingManagementTrainingParticipantEntityModel, AXMTrainingManagementTrainingTypeEntityModel };
