@acorex/modules 20.7.20 → 20.7.21

package/fesm2022/acorex-modules-reservation-management-acorex-modules-reservation-management-CkHGIQ38.mjs

@@ -0,0 +1,2135 @@
+import { AXPWidgetsList, AXPCommonMenuKeys } from '@acorex/modules/common';
+import { createAllQueryView, AXPEntityQueryType, AXPEntityCommandScope, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, AXPSearchCommandProvider } from '@acorex/platform/common';
+import { AXMEntityCrudServiceImpl, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions, entityDetailsSimpleCondition, AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, inject, Injector } from '@angular/core';
+import { AXPSystemActionType, AXP_MODULE_MANIFEST_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+
+//#region ----   Root Configuration   ----
+const config = {
+    i18n: 'reservation-management',
+    module: 'ReservationManagement',
+    route: 'reservation-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: config.route,
+        name: config.module,
+        title: '@reservation-management:module.title',
+        icon: 'fa-light fa-calendar-check',
+    },
+    entities: {
+        reservationType: {
+            name: 'ReservationType',
+            source: `${config.module}.ReservationType`,
+            title: '@reservation-management:reservation-types.entities.reservation-type.title',
+            titlePlural: '@reservation-management:reservation-types.entities.reservation-type.plural',
+            icon: 'fa-light fa-list',
+        },
+        reservationStatus: {
+            name: 'ReservationStatus',
+            source: `${config.module}.ReservationStatus`,
+            title: '@reservation-management:reservation-statuses.entities.reservation-status.title',
+            titlePlural: '@reservation-management:reservation-statuses.entities.reservation-status.plural',
+            icon: 'fa-light fa-flag',
+        },
+        reservationClass: {
+            name: 'ReservationClass',
+            source: `${config.module}.ReservationClass`,
+            title: '@reservation-management:reservation-classes.entities.reservation-class.title',
+            titlePlural: '@reservation-management:reservation-classes.entities.reservation-class.plural',
+            icon: 'fa-light fa-tag',
+        },
+        reservation: {
+            name: 'Reservation',
+            source: `${config.module}.Reservation`,
+            title: '@reservation-management:reservations.entities.reservation.title',
+            titlePlural: '@reservation-management:reservations.entities.reservation.plural',
+            icon: 'fa-light fa-calendar-check',
+        },
+        reservationEvent: {
+            name: 'ReservationEvent',
+            source: `${config.module}.ReservationEvent`,
+            title: '@reservation-management:reservation-events.entities.reservation-event.title',
+            titlePlural: '@reservation-management:reservation-events.entities.reservation-event.plural',
+            icon: 'fa-light fa-calendar-alt',
+        },
+        reservationHold: {
+            name: 'ReservationHold',
+            source: `${config.module}.ReservationHold`,
+            title: '@reservation-management:reservation-holds.entities.reservation-hold.title',
+            titlePlural: '@reservation-management:reservation-holds.entities.reservation-hold.plural',
+            icon: 'fa-light fa-pause-circle',
+        },
+        reservationStatusTransition: {
+            name: 'ReservationStatusTransition',
+            source: `${config.module}.ReservationStatusTransition`,
+            title: '@reservation-management:reservation-status-transitions.entities.reservation-status-transition.title',
+            titlePlural: '@reservation-management:reservation-status-transitions.entities.reservation-status-transition.plural',
+            icon: 'fa-light fa-right-left',
+        },
+        reservationResourceType: {
+            name: 'ReservationResourceType',
+            source: `${config.module}.ReservationResourceType`,
+            title: '@reservation-management:reservation-resource-types.entities.reservation-resource-type.title',
+            titlePlural: '@reservation-management:reservation-resource-types.entities.reservation-resource-type.plural',
+            icon: 'fa-light fa-cube',
+        },
+        reservationClassStatus: {
+            name: 'ReservationClassStatus',
+            source: `${config.module}.ReservationClassStatus`,
+            title: '@reservation-management:reservation-class-statuses.entities.reservation-class-status.title',
+            titlePlural: '@reservation-management:reservation-class-statuses.entities.reservation-class-status.plural',
+            icon: 'fa-light fa-circle-nodes',
+        },
+        reservationClassType: {
+            name: 'ReservationClassType',
+            source: `${config.module}.ReservationClassType`,
+            title: '@reservation-management:reservation-class-types.entities.reservation-class-type.title',
+            titlePlural: '@reservation-management:reservation-class-types.entities.reservation-class-type.plural',
+            icon: 'fa-light fa-layer-group',
+        },
+    },
+};
+//#endregion
+
+class AXPReservationManagementReservationService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationServiceImpl extends AXPReservationManagementReservationService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservation.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Factory   ----
+async function reservationFactory(injector) {
+    const dataService = injector.get(AXPReservationManagementReservationService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reservation.name,
+        title: RootConfig.entities.reservation.title,
+        icon: RootConfig.entities.reservation.icon,
+        formats: {
+            individual: RootConfig.entities.reservation.title,
+            plural: RootConfig.entities.reservation.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ code }}',
+            },
+        },
+        plugins: [{ name: 'notes' }],
+        groups: [
+            {
+                id: 'reservation-information',
+                title: '@reservation-management:reservations.entities.reservation.groups.reservation-information',
+            },
+            {
+                id: 'approve-information',
+                title: '@reservation-management:reservations.entities.reservation.groups.approve-information',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
+            },
+            {
+                name: 'reservationResourceTypeId',
+                title: '@reservation-management:reservations.entities.reservation.fields.reservation-resource-type-id',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reservationResourceType.name}`,
+                            look: 'select',
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['name', 'title', 'reservationClass'],
+                            expose: [
+                                { source: 'id', target: 'reservationResourceType.id' },
+                                { source: 'title', target: 'reservationResourceType.title' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'reservationTypeId',
+                title: '@reservation-management:reservations.entities.reservation.fields.reservation-type-id',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reservationType.name}`,
+                            look: 'select',
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['name', 'title', 'isBlocking'],
+                            expose: [
+                                { source: 'id', target: 'reservationType.id' },
+                                { source: 'title', target: 'reservationType.title' },
+                                { source: 'name', target: 'reservationType.name' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'reservationStatusId',
+                title: '@reservation-management:reservations.entities.reservation.fields.reservation-status-id',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reservationStatus.name}`,
+                            look: 'select',
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['name', 'title', 'color'],
+                            expose: [
+                                { source: 'id', target: 'reservationStatus.id' },
+                                { source: 'title', target: 'reservationStatus.title' },
+                                { source: 'name', target: 'reservationStatus.name' },
+                                { source: 'color', target: 'reservationStatus.color' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'resourceEntityId',
+                title: '@reservation-management:reservations.entities.reservation.fields.resource-entity-id',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.SelectBox,
+                        options: {
+                            valueField: 'entity',
+                            textField: 'title',
+                            allowSearch: true,
+                            dataSource: 'entities'
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            // {
+            //   name: 'resourceId',
+            //   title: '@reservation-management:reservations.entities.reservation.fields.resource-id',
+            //   groupId: 'reservation-information',
+            //   schema: {
+            //     dataType: 'object',
+            //     interface: {
+            //       type: AXPWidgetsCatalog.lookup,
+            //       options: {
+            //         entity: `{{ context.eval('resourceEntityId') }}`,
+            //         textField: 'title',
+            //         valueField: 'id',
+            //         columns: ['title'],
+            //         expose: [
+            //           { source: 'id', target: 'resource.id' },
+            //           { source: 'title', target: 'resource.title' },
+            //         ],
+            //         triggers: [
+            //           {
+            //             event: "{{ events.context('resourceEntityId') }}",
+            //             action: `{{ widget.refresh() }}`,
+            //           },
+            //         ],
+            //       },
+            //     },
+            //   },
+            //   options: {
+            //     sort: { enabled: true },
+            //     filter: { advance: { enabled: true }, inline: { enabled: true } },
+            //   },
+            //   validations: [{ rule: 'required' }],
+            // },
+            {
+                name: 'startDate',
+                title: '@reservation-management:reservations.entities.reservation.fields.start-date',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'date',
+                    // readonly : true ,
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            format: 'datetime',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'endDate',
+                title: '@reservation-management:reservations.entities.reservation.fields.end-date',
+                groupId: 'reservation-information',
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            format: 'datetime',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'requestedById',
+                title: '@reservation-management:reservations.entities.reservation.fields.requested-by-id',
+                groupId: 'approve-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'HumanCapitalManagement.Employee',
+                            textField: 'person.displayName',
+                            valueField: 'id',
+                            columns: ['person.displayName', 'person.primaryContact'],
+                            expose: [
+                                { source: 'id', target: 'requestedBy.id' },
+                                { source: 'person.displayName', target: 'requestedBy.displayName' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'requestedDate',
+                title: '@reservation-management:reservations.entities.reservation.fields.requested-date',
+                groupId: 'approve-information',
+                schema: {
+                    dataType: 'date',
+                    readonly: true,
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            format: 'datetime',
+                            defaultValue: Date.now(),
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'approvedById',
+                title: '@reservation-management:reservations.entities.reservation.fields.approved-by-id',
+                groupId: 'approve-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'HumanCapitalManagement.Employee',
+                            textField: 'person.displayName',
+                            valueField: 'id',
+                            columns: ['person.displayName', 'person.primaryContact'],
+                            expose: [
+                                { source: 'id', target: 'approvedBy.id' },
+                                { source: 'person.displayName', target: 'approvedBy.displayName' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'approvedDate',
+                title: '@reservation-management:reservations.entities.reservation.fields.approved-date',
+                groupId: 'approve-information',
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: {
+                            format: 'datetime',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+        ],
+        columns: [
+            { name: 'reservationTypeId', options: { dataPath: 'reservationType' } },
+            { name: 'reservationResourceTypeId', options: { dataPath: 'reservationResourceType' } },
+            // { name: 'resourceId', options: { dataPath: 'resource' } },
+            { name: 'startDate' },
+            { name: 'endDate' },
+            { name: 'reservationStatusId', options: { dataPath: 'reservationStatus' } },
+            { name: 'requestedById', options: { dataPath: 'requestedBy' } },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return { id: await dataService.insertOne(data) };
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: e.filter,
+                        sort: e.sort,
+                    });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        { id: 'reservation-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'approve-information', order: 2, layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: [
+                        { name: 'reservationTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationResourceTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationStatusId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'resourceEntityId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        // { name: 'resourceId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'startDate', layout: { positions: { lg: { colStart: 1, colSpan: 6 } } } },
+                        { name: 'endDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                },
+                update: {
+                    sections: [
+                        { id: 'reservation-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'approve-information', order: 2, layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: [
+                        { name: 'reservationTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationResourceTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationStatusId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'resourceEntityId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        // { name: 'resourceId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'startDate', layout: { positions: { lg: { colStart: 1, colSpan: 6 } } } },
+                        { name: 'endDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [
+                        { id: 'reservation-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'approve-information', order: 2, layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: [
+                        { name: 'reservationTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationResourceTypeId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationStatusId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'resourceEntityId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        // { name: 'resourceId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'startDate', layout: { positions: { lg: { colStart: 1, colSpan: 6 } } } },
+                        { name: 'endDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'requestedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedById', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'approvedDate', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'startDate', dir: 'desc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var reservation_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reservationFactory: reservationFactory
+});
+
+class AXPReservationManagementReservationEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationService,
+                useClass: AXPReservationManagementReservationServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationService,
+                            useClass: AXPReservationManagementReservationServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXPReservationManagementReservationClassService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationClassServiceImpl extends AXPReservationManagementReservationClassService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationClass.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Factory   ----
+async function reservationClassFactory(injector) {
+    const dataService = injector.get(AXPReservationManagementReservationClassService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reservationClass.name,
+        title: RootConfig.entities.reservationClass.title,
+        icon: RootConfig.entities.reservationClass.icon,
+        plugins: [{ name: 'archive' }],
+        formats: {
+            individual: RootConfig.entities.reservationClass.title,
+            plural: RootConfig.entities.reservationClass.titlePlural,
+            displayName: '@reservation-management:reservation-classes.entities.reservation-class.title',
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ code }}',
+            },
+        },
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.reservationClassStatus.name}`,
+                title: '@reservation-management:reservation-classes.entities.reservation-class.related-entities.reservation-class-statuses.title',
+                icon: RootConfig.entities.reservationClassStatus.icon,
+                conditions: [entityDetailsSimpleCondition('reservationClassId')],
+                actions: [...entityDetailsCrudActions('reservationClassId')],
+                layout: { type: 'page-list', position: 'after', order: 1 },
+            },
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.reservationStatusTransition.name}`,
+                title: '@reservation-management:reservation-classes.entities.reservation-class.related-entities.reservation-status-transitions.title',
+                icon: RootConfig.entities.reservationStatusTransition.icon,
+                conditions: [entityDetailsSimpleCondition('reservationClassId')],
+                actions: [...entityDetailsCrudActions('reservationClassId')],
+                layout: { type: 'page-list', position: 'after', order: 2 },
+            },
+        ],
+        groups: [
+            {
+                id: 'basic-information',
+                title: '@reservation-management:reservation-classes.entities.reservation-class.groups.basic-information',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
+            },
+            {
+                name: 'name',
+                title: '@reservation-management:reservation-classes.entities.reservation-class.fields.name.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-classes.entities.reservation-class.fields.name.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@reservation-management:reservation-classes.entities.reservation-class.fields.title.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-classes.entities.reservation-class.fields.title.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'reservationTypeIds',
+                title: '@reservation-management:reservation-classes.entities.reservation-class.fields.reservation-type-ids.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reservationType.name}`,
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['name', 'title'],
+                            multiple: true,
+                            expose: [
+                                { source: 'id', target: 'reservationTypes.{id}' },
+                                { source: 'title', target: 'reservationTypes.{title}' },
+                                { source: 'name', target: 'reservationTypes.{name}' },
+                            ],
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'reservationTypes',
+                title: '@reservation-management:reservation-classes.entities.reservation-class.fields.reservation-type-ids.title',
+                schema: {
+                    dataType: 'array',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
+                },
+            },
+        ],
+        columns: [
+            { name: 'name', options: { order: 1 } },
+            { name: 'title', options: { order: 2 } },
+            { name: 'reservationTypeIds', options: { order: 3, dataPath: 'reservationTypes' } }
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return { id: await dataService.insertOne(data) };
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: e.filter,
+                        sort: e.sort,
+                    });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        { id: 'basic-information', order: 1 },
+                    ],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationTypeIds', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                update: {
+                    sections: [
+                        { id: 'basic-information', order: 1 },
+                    ],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationTypeIds', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [
+                        { id: 'basic-information', order: 1 },
+                    ],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'reservationTypeIds', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [
+                        ...entityMasterCrudActions(),
+                        {
+                            title: '@general:actions.archive.title',
+                            command: 'archive-entity',
+                            priority: 'secondary',
+                            type: AXPSystemActionType.Archive,
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'name', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var reservationClass_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reservationClassFactory: reservationClassFactory
+});
+
+class AXPReservationManagementReservationEventService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationEventServiceImpl extends AXPReservationManagementReservationEventService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationEvent.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Factory   ----
+async function reservationEventFactory(injector) {
+    const dataService = injector.get(AXPReservationManagementReservationEventService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reservationEvent.name,
+        title: RootConfig.entities.reservationEvent.title,
+        icon: RootConfig.entities.reservationEvent.icon,
+        formats: {
+            individual: RootConfig.entities.reservationEvent.title,
+            plural: RootConfig.entities.reservationEvent.titlePlural,
+            searchResult: {
+                title: '',
+            },
+        },
+        // Property groups
+        groups: [
+            {
+                id: 'basic-information',
+                title: '@reservation-management:reservation-events.entities.reservation-event.groups.basic-information',
+            },
+        ],
+        // Entity properties
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                groupId: 'basic-information',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    visible: false,
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            readonly: true,
+                            visible: false,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'reservationId',
+                title: '@ ',
+                groupId: 'basic-information',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.reservation.name}`,
+                            expose: [
+                                { source: 'id', target: 'reservation.{id}' },
+                                { source: 'resource', target: 'reservation.{resource}' },
+                            ],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+        ],
+        // Columns for list views
+        columns: [
+            { name: 'reservationId', options: { dataPath: 'reservation' } },
+            { name: 'reservationEventId', options: { dataPath: 'reservationEvent' } },
+            { name: 'eventDate' },
+            { name: 'actorId', options: { dataPath: 'actor' } },
+            { name: 'fromStatusId', options: { dataPath: 'fromStatus' } },
+            { name: 'toStatusId', options: { dataPath: 'toStatus' } },
+        ],
+        // Commands
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return await dataService.insertOne(data);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+        },
+        // Queries
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: e.filter,
+                    });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        // Interfaces
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } }],
+                    properties: [
+                        {
+                            name: 'id',
+                            layout: { positions: { lg: { colSpan: 6 } } },
+                        },
+                        {
+                            name: 'reservationId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'reservationEventId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'eventDate',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'actorId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'fromStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'toStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } }],
+                    properties: [
+                        {
+                            name: 'id',
+                            layout: { positions: { lg: { colSpan: 6 } } },
+                        },
+                        {
+                            name: 'reservationId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'reservationEventId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'eventDate',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'actorId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'fromStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'toStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{ resource }}',
+                    sections: [{ id: 'basic-information', order: 1, layout: { positions: { lg: { colSpan: 12 } } } }],
+                    properties: [
+                        {
+                            name: 'id',
+                            layout: { positions: { lg: { colSpan: 6 } } },
+                        },
+                        {
+                            name: 'reservationId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'reservationEventId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'eventDate',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'actorId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'fromStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                        {
+                            name: 'toStatusId',
+                            layout: { positions: { lg: { colSpan: 12 } } },
+                        },
+                    ],
+                    actions: [
+                        {
+                            title: '@general:actions.edit.title',
+                            command: 'quick-modify-entity',
+                            priority: 'primary',
+                            type: 'update',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: '@general:actions.create.title',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: '@general:actions.edit.title',
+                            command: 'quick-modify-entity',
+                            priority: 'primary',
+                            type: 'update',
+                            scope: AXPEntityCommandScope.Individual,
+                            default: true, // Enable double-click to open edit mode
+                        },
+                        {
+                            title: '@general:actions.delete.title',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var reservationEvent_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reservationEventFactory: reservationEventFactory
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Service   ----
+class AXPReservationManagementReservationStatusService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationStatusServiceImpl extends AXPReservationManagementReservationStatusService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationStatus.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Factory   ----
+async function reservationStatusFactory(injector) {
+    const dataService = injector.get(AXPReservationManagementReservationStatusService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reservationStatus.name,
+        title: RootConfig.entities.reservationStatus.title,
+        icon: RootConfig.entities.reservationStatus.icon,
+        formats: {
+            individual: RootConfig.entities.reservationStatus.title,
+            plural: RootConfig.entities.reservationStatus.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ name }}',
+            },
+        },
+        groups: [
+            {
+                id: 'basic-information',
+                title: '@reservation-management:reservation-statuses.entities.reservation-status.groups.basic-information',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true },
+            },
+            {
+                name: 'name',
+                title: '@reservation-management:reservation-statuses.entities.reservation-status.fields.name.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-statuses.entities.reservation-status.fields.name.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@reservation-management:reservation-statuses.entities.reservation-status.fields.title.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-statuses.entities.reservation-status.fields.title.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'color',
+                title: '@reservation-management:reservation-statuses.entities.reservation-status.fields.color.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.ColorPalette,
+                        options: {},
+                    },
+                },
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'icon',
+                title: '@reservation-management:reservation-statuses.entities.reservation-status.fields.icon.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.iconChooser,
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'name', options: { order: 1 } }, { name: 'title', options: { order: 2 } }, { name: 'color', options: { order: 3 } }, { name: 'icon', options: { order: 4 } }],
+        commands: {
+        // create: {
+        //   execute: async (data: any) => {
+        //     return { id: await dataService.insertOne(data) };
+        //   },
+        // },
+        // update: {
+        //   execute: async (data: any) => {
+        //     return await dataService.updateOne(data.id, data);
+        //   },
+        // },
+        // delete: {
+        //   execute: async (id: string) => {
+        //     return await dataService.deleteOne(id);
+        //   },
+        // },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: e.filter,
+                        sort: e.sort,
+                    });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'color', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'icon', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'code', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'color', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'icon', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'color', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'icon', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions({ create: false, delete: false })],
+                    views: [
+                        createAllQueryView({
+                            sorts: [
+                                { name: 'name', dir: 'asc' },
+                            ],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var reservationStatus_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reservationStatusFactory: reservationStatusFactory
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reservation Status Entity Module   ----
+class AXPReservationManagementReservationStatusEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationStatusService,
+                useClass: AXPReservationManagementReservationStatusServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationStatusService,
+                            useClass: AXPReservationManagementReservationStatusServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Service   ----
+class AXPReservationManagementReservationTypeService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationTypeServiceImpl extends AXPReservationManagementReservationTypeService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationType.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Entity Factory   ----
+async function reservationTypeFactory(injector) {
+    const dataService = injector.get(AXPReservationManagementReservationTypeService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.reservationType.name,
+        title: RootConfig.entities.reservationType.title,
+        icon: RootConfig.entities.reservationType.icon,
+        plugins: [{ name: 'archive' }],
+        formats: {
+            individual: RootConfig.entities.reservationType.title,
+            plural: RootConfig.entities.reservationType.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ name }}',
+            },
+        },
+        groups: [
+            {
+                id: 'basic-information',
+                title: '@reservation-management:reservation-types.entities.reservation-type.groups.basic-information',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                schema: { dataType: 'uuid', visible: false, nullable: false, readonly: true, unique: { enabled: true } },
+            },
+            {
+                name: 'name',
+                title: '@reservation-management:reservation-types.entities.reservation-type.fields.name.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-types.entities.reservation-type.fields.name.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@reservation-management:reservation-types.entities.reservation-type.fields.title.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@reservation-management:reservation-types.entities.reservation-type.fields.title.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'isBlocking',
+                title: '@reservation-management:reservation-types.entities.reservation-type.fields.is-blocking.title',
+                groupId: 'basic-information',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+            },
+        ],
+        columns: [{ name: 'name', options: { order: 1 } }, { name: 'title', options: { order: 2 } }, { name: 'resourceEntityIds', options: { order: 3 } }, { name: 'isBlocking', options: { order: 4 } }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return { id: await dataService.insertOne(data) };
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({
+                        skip: e.skip,
+                        take: e.take,
+                        filter: e.filter,
+                        sort: e.sort,
+                    });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isBlocking', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isBlocking', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ title }}',
+                    sections: [{ id: 'basic-information' }],
+                    properties: [
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isBlocking', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [
+                        ...entityMasterCrudActions(),
+                        {
+                            title: '@general:actions.archive.title',
+                            command: 'archive-entity',
+                            priority: 'secondary',
+                            type: AXPSystemActionType.Archive,
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'name', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var reservationType_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reservationTypeFactory: reservationTypeFactory
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reservation Type Entity Module   ----
+class AXPReservationManagementReservationTypeEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationTypeService,
+                useClass: AXPReservationManagementReservationTypeServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationTypeEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationTypeService,
+                            useClass: AXPReservationManagementReservationTypeServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMReservationManagementEntityProvider {
+    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.reservationType.name:
+                    return (await Promise.resolve().then(function () { return reservationType_entity; })).reservationTypeFactory(this.injector);
+                case RootConfig.entities.reservationStatus.name:
+                    return (await Promise.resolve().then(function () { return reservationStatus_entity; })).reservationStatusFactory(this.injector);
+                case RootConfig.entities.reservationClass.name:
+                    return (await Promise.resolve().then(function () { return reservationClass_entity; })).reservationClassFactory(this.injector);
+                case RootConfig.entities.reservationEvent.name:
+                    return (await Promise.resolve().then(function () { return reservationEvent_entity; })).reservationEventFactory(this.injector);
+                case RootConfig.entities.reservation.name:
+                    return (await Promise.resolve().then(function () { return reservation_entity; })).reservationFactory(this.injector);
+                case RootConfig.entities.reservationStatusTransition.name:
+                    return (await import('./acorex-modules-reservation-management-reservation-status-transition.entity-BT8GQ9MC.mjs')).reservationStatusTransitionFactory(this.injector);
+                case RootConfig.entities.reservationResourceType.name:
+                    return (await import('./acorex-modules-reservation-management-reservation-resource-type.entity-BXb0FTQ5.mjs')).reservationResourceTypeFactory(this.injector);
+                case RootConfig.entities.reservationClassStatus.name:
+                    return (await import('./acorex-modules-reservation-management-reservation-class-status.entity-Clyj7r2x.mjs')).reservationClassStatusFactory(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.16", ngImport: i0, type: AXMReservationManagementEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+var entity_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMReservationManagementEntityProvider: AXMReservationManagementEntityProvider
+});
+
+const AXMReservationManagementMenuKeys = {
+    ReservationTypes: 'reservation-management:Menu:ReservationTypes',
+    ReservationStatuses: 'reservation-management:Menu:ReservationStatuses',
+    ReservationClasses: 'reservation-management:Menu:ReservationClasses',
+    Reservations: 'reservation-management:Menu:Reservations',
+};
+
+const AXMPermissionsKeys = {
+    ReservationManagement: {
+        Management: 'ReservationManagement:Permission:Management',
+        ReservationType: {
+            Management: 'ReservationManagement:Permission:ReservationType.Management',
+        },
+        ReservationStatus: {
+            Management: 'ReservationManagement:Permission:ReservationStatus.Management',
+        },
+        ReservationClass: {
+            Management: 'ReservationManagement:Permission:ReservationClass.Management',
+        },
+        Reservation: {
+            Management: 'ReservationManagement:Permission:Reservation.Management',
+        },
+    },
+};
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Menu Provider   ----
+class AXMReservationManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const keys = AXMPermissionsKeys.ReservationManagement;
+        // Configuration > Reservation: Types, Statuses, Classes
+        const reservationConfigMenu = context.find(AXPCommonMenuKeys.ReservationConfig);
+        if (!reservationConfigMenu.exists) {
+            context.find(AXPCommonMenuKeys.Configuration).addItems([
+                {
+                    name: AXPCommonMenuKeys.ReservationConfig,
+                    priority: 8942,
+                    text: '@general:menus.reservation.title',
+                    icon: module.icon,
+                    type: 'menu',
+                    children: [],
+                    policy: {
+                        features: [module.name],
+                    },
+                },
+            ]);
+        }
+        context.find(AXPCommonMenuKeys.ReservationConfig).addItems([
+            {
+                name: AXMReservationManagementMenuKeys.ReservationTypes,
+                text: '@reservation-management:reservation-types.menus.reservation-types.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.reservationType.name),
+                icon: 'fa-light fa-list',
+                priority: 1,
+                policy: {
+                    permissions: [keys.ReservationType.Management],
+                },
+            },
+            {
+                name: AXMReservationManagementMenuKeys.ReservationStatuses,
+                text: '@reservation-management:reservation-statuses.menus.reservation-statuses.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.reservationStatus.name),
+                icon: 'fa-light fa-flag',
+                priority: 2,
+                policy: {
+                    permissions: [keys.ReservationStatus.Management],
+                },
+            },
+            {
+                name: AXMReservationManagementMenuKeys.ReservationClasses,
+                text: '@reservation-management:reservation-classes.menus.reservation-classes.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.reservationClass.name),
+                icon: 'fa-light fa-tag',
+                priority: 3,
+                policy: {
+                    permissions: [keys.ReservationClass.Management],
+                },
+            },
+        ]);
+        // Root under MODULES: Reservations (operational)
+        context.addItems([
+            {
+                name: AXMReservationManagementMenuKeys.Reservations,
+                priority: 9051,
+                text: '@general:menus.reservations.title',
+                icon: RootConfig.entities.reservation.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.reservation.name),
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.Reservation.Management],
+                },
+                children: [
+                    {
+                        name: AXMReservationManagementMenuKeys.ReservationTypes,
+                        text: '@reservation-management:reservation-types.menus.reservation-types.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.reservationType.name),
+                        icon: 'fa-light fa-list',
+                        priority: 1,
+                    },
+                    {
+                        name: AXMReservationManagementMenuKeys.ReservationClasses,
+                        text: '@reservation-management:reservation-classes.menus.reservation-classes.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.reservationClass.name),
+                        icon: 'fa-light fa-tag',
+                        priority: 2,
+                    },
+                    {
+                        name: AXMReservationManagementMenuKeys.ReservationTypes,
+                        text: '@reservation-management:reservation-resource-types.menus.reservation-resource-types.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.reservationResourceType.name),
+                        icon: 'fa-light fa-cubes',
+                        priority: 3,
+                    },
+                    {
+                        name: AXMReservationManagementMenuKeys.ReservationStatuses,
+                        text: '@reservation-management:reservation-statuses.menus.reservation-statuses.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.reservationStatus.name),
+                        icon: 'fa-light fa-flag',
+                        priority: 4,
+                    },
+                    {
+                        name: AXMReservationManagementMenuKeys.Reservations,
+                        text: '@reservation-management:reservations.menus.reservations.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.reservation.name),
+                        icon: 'fa-light fa-calendar-check',
+                        priority: 5,
+                    },
+                ],
+            },
+        ]);
+    }
+}
+//#endregion
+
+var menu_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMReservationManagementMenuProvider: AXMReservationManagementMenuProvider
+});
+
+class AXMReservationManagementPermissionDefinitionProvider {
+    constructor() {
+        this.translateService = inject(AXTranslationService);
+    }
+    async define(context) {
+        const scope = RootConfig.config.i18n;
+        const moduleTitle = await this.translateService.translateAsync(`@${scope}:module.title`);
+        const typeTrans = async (key, field = 'title') => await this.translateService.translateAsync(`@${scope}:reservation-types.permissions.${key}.${field}`);
+        const statusTrans = async (key, field = 'title') => await this.translateService.translateAsync(`@${scope}:reservation-statuses.permissions.${key}.${field}`);
+        const classTrans = async (key, field = 'title') => await this.translateService.translateAsync(`@${scope}:reservation-classes.permissions.${key}.${field}`);
+        const reservationTitle = await this.translateService.translateAsync(`@${scope}:reservations.permissions.reservations.title`);
+        const reservationDesc = await this.translateService.translateAsync(`@${scope}:reservations.permissions.reservations.description`);
+        const keys = AXMPermissionsKeys.ReservationManagement;
+        context
+            .addGroup(RootConfig.module.name, moduleTitle)
+            .addPermission(keys.ReservationType.Management, await typeTrans('manage'), await typeTrans('manage', 'description'))
+            .endPermission()
+            .addPermission(keys.ReservationStatus.Management, await statusTrans('manage'), await statusTrans('manage', 'description'))
+            .endPermission()
+            .addPermission(keys.ReservationClass.Management, await classTrans('manage'), await classTrans('manage', 'description'))
+            .endPermission()
+            .addPermission(keys.Reservation.Management, reservationTitle, reservationDesc)
+            .endPermission()
+            .endGroup();
+    }
+}
+
+var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMReservationManagementPermissionDefinitionProvider: AXMReservationManagementPermissionDefinitionProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Event Type Entity Module   ----
+class AXPReservationManagementReservationClassEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationClassService,
+                useClass: AXPReservationManagementReservationClassServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationClassService,
+                            useClass: AXPReservationManagementReservationClassServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXPReservationManagementReservationClassStatusService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationClassStatusServiceImpl extends AXPReservationManagementReservationClassStatusService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationClassStatus.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reservation Class Status Entity Module   ----
+class AXPReservationManagementReservationClassStatusEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationClassStatusService,
+                useClass: AXPReservationManagementReservationClassStatusServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationClassStatusEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationClassStatusService,
+                            useClass: AXPReservationManagementReservationClassStatusServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Hold Type Entity Module   ----
+class AXPReservationManagementReservationEventEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationEventService,
+                useClass: AXPReservationManagementReservationEventServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationEventEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationEventService,
+                            useClass: AXPReservationManagementReservationEventServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Service   ----
+class AXPReservationManagementReservationResourceTypeService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationResourceTypeServiceImpl extends AXPReservationManagementReservationResourceTypeService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationResourceType.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reservation Resource Type Entity Module   ----
+class AXPReservationManagementReservationResourceTypeEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationResourceTypeService,
+                useClass: AXPReservationManagementReservationResourceTypeServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationResourceTypeEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationResourceTypeService,
+                            useClass: AXPReservationManagementReservationResourceTypeServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Service   ----
+class AXPReservationManagementReservationStatusTransitionService extends AXMEntityCrudServiceImpl {
+}
+class AXPReservationManagementReservationStatusTransitionServiceImpl extends AXPReservationManagementReservationStatusTransitionService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.reservationStatusTransition.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reservation Status Transition Entity Module   ----
+class AXPReservationManagementReservationStatusTransitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionEntityModule, providers: [
+            {
+                provide: AXPReservationManagementReservationStatusTransitionService,
+                useClass: AXPReservationManagementReservationStatusTransitionServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPReservationManagementReservationStatusTransitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXPReservationManagementReservationStatusTransitionService,
+                            useClass: AXPReservationManagementReservationStatusTransitionServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Reservation Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const ReservationManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: false,
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMReservationManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementModule, imports: [AXPReservationManagementReservationTypeEntityModule,
+            AXPReservationManagementReservationStatusEntityModule,
+            AXPReservationManagementReservationClassEntityModule,
+            AXPReservationManagementReservationClassStatusEntityModule,
+            AXPReservationManagementReservationStatusTransitionEntityModule,
+            AXPReservationManagementReservationResourceTypeEntityModule,
+            AXPReservationManagementReservationEventEntityModule,
+            AXPReservationManagementReservationEntityModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: ReservationManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMReservationManagementPermissionDefinitionProvider)),
+            provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMReservationManagementMenuProvider)),
+            provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMReservationManagementEntityProvider)),
+            provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return search_provider; }).then((m) => m.AXMReservationManagementSearchCommandProvider)),
+        ], imports: [AXPReservationManagementReservationTypeEntityModule,
+            AXPReservationManagementReservationStatusEntityModule,
+            AXPReservationManagementReservationClassEntityModule,
+            AXPReservationManagementReservationClassStatusEntityModule,
+            AXPReservationManagementReservationStatusTransitionEntityModule,
+            AXPReservationManagementReservationResourceTypeEntityModule,
+            AXPReservationManagementReservationEventEntityModule,
+            AXPReservationManagementReservationEntityModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXMReservationManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPReservationManagementReservationTypeEntityModule,
+                        AXPReservationManagementReservationStatusEntityModule,
+                        AXPReservationManagementReservationClassEntityModule,
+                        AXPReservationManagementReservationClassStatusEntityModule,
+                        AXPReservationManagementReservationStatusTransitionEntityModule,
+                        AXPReservationManagementReservationResourceTypeEntityModule,
+                        AXPReservationManagementReservationEventEntityModule,
+                        AXPReservationManagementReservationEntityModule,
+                    ],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: ReservationManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMReservationManagementPermissionDefinitionProvider)),
+                        provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMReservationManagementMenuProvider)),
+                        provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then((m) => m.AXMReservationManagementEntityProvider)),
+                        provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return search_provider; }).then((m) => m.AXMReservationManagementSearchCommandProvider)),
+                    ],
+                }]
+        }] });
+
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+        // {
+        //   group: 'command',
+        //  title: 'New Form Template',
+        //  icon: RootConfig.entities.template.icon,
+        //  description: 'Create a new form template for designing reusable forms.', // Added description
+        //  commands: {
+        //    'create-entity': {
+        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
+        //    },
+        //  },
+        // }
+        ];
+    }
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Search Provider   ----
+class AXMReservationManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                group: 'entity',
+                title: '@reservation-management:assets.search.create-asset.title',
+                icon: RootConfig.entities.reservation.icon,
+                description: '@reservation-management:assets.search.create-asset.description',
+                command: {
+                    name: 'create-entity',
+                    options: {
+                        entity: `${RootConfig.module.name}.${RootConfig.entities.reservation.name}`,
+                    },
+                },
+            },
+            // {
+            //     group: 'entity',
+            //     title: '@asset-management:asset-statuses.search.create-asset-status.title',
+            //     icon: RootConfig.entities.assetStatus.icon,
+            //     description: '@asset-management:asset-statuses.search.create-asset-status.description',
+            //     command: {
+            //         name: 'create-entity',
+            //         options: {
+            //             entity: `${RootConfig.module.name}.${RootConfig.entities.assetStatus.name}`,
+            //         },
+            //     },
+            // },
+        ];
+    }
+}
+//#endregion
+
+var search_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMReservationManagementSearchCommandProvider: AXMReservationManagementSearchCommandProvider
+});
+
+class AXMSettingProvider {
+    async provide(context) {
+        // context
+        //   // Add Form Template Group
+        //   .addGroup('form-template', 'Form Template', 'Settings related to form templates.', RootConfig.module.icon)
+        //   // Start Interface Section
+        //   .addSection('interface', 'UI Interface', 'Customize the user interface for forms.')
+        //   .addSetting({
+        //     key: 'history-panel',
+        //     title: 'Show History Panel',
+        //     scope: 'U',
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     widget: {
+        //       type: AXPWidgetsCatalog.toggle,
+        //     },
+        //     description: 'Enable or disable the history panel for forms.',
+        //     validationRules: [
+        //       {
+        //         rule: 'required',
+        //       },
+        //     ],
+        //   })
+        //   .endSection()
+        //   .endGroup();
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPReservationManagementReservationStatusTransitionService as A, AXMSearchCommandProvider as B, AXMReservationManagementSearchCommandProvider as C, AXMSettingProvider as D, RootConfig as R, AXPReservationManagementReservationResourceTypeService as a, AXPReservationManagementReservationClassStatusService as b, AXPReservationManagementReservationEntityModule as c, AXPReservationManagementReservationService as d, AXPReservationManagementReservationServiceImpl as e, reservationClassFactory as f, AXPReservationManagementReservationClassService as g, AXPReservationManagementReservationClassServiceImpl as h, reservationEventFactory as i, AXPReservationManagementReservationEventService as j, AXPReservationManagementReservationEventServiceImpl as k, reservationStatusFactory as l, AXPReservationManagementReservationStatusEntityModule as m, AXPReservationManagementReservationStatusService as n, AXPReservationManagementReservationStatusServiceImpl as o, reservationTypeFactory as p, AXPReservationManagementReservationTypeEntityModule as q, reservationFactory as r, AXPReservationManagementReservationTypeService as s, AXPReservationManagementReservationTypeServiceImpl as t, AXMReservationManagementEntityProvider as u, AXMReservationManagementMenuKeys as v, AXMReservationManagementMenuProvider as w, AXMReservationManagementPermissionDefinitionProvider as x, AXMPermissionsKeys as y, AXMReservationManagementModule as z };
+//# sourceMappingURL=acorex-modules-reservation-management-acorex-modules-reservation-management-CkHGIQ38.mjs.map