@acorex/platform 21.0.0-next.5 → 21.0.0-next.51

package/fesm2022/acorex-platform-domain.mjs

@@ -1,204 +1,39 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, makeEnvironmentProviders, inject, NgModule, Injectable } from '@angular/core';
-import { AXPEntityService } from '@acorex/platform/layout/entity';
-import { AXPCommandRegistry, AXPQueryRegistry, AXPRuntimeModule } from '@acorex/platform/runtime';
+import { InjectionToken, inject, NgModule, Injectable, makeEnvironmentProviders } from '@angular/core';
+import { AXPRuntimeModule } from '@acorex/platform/runtime';
 
+/**
+ * Token for entity CRUD setup. Consumed by AXPDomainModule.
+ * The actual provider is provideEntity() from @acorex/platform/layout/entity
+ * to avoid circular dependency (domain must not depend on layout/entity).
+ */
 const AXP_ENTITY_CRUD_SETUP = new InjectionToken('AXP_ENTITY_CRUD_SETUP');
-function provideEntity(entityKeys) {
-    return makeEnvironmentProviders([
-        {
-            provide: AXP_ENTITY_CRUD_SETUP,
-            multi: true,
-            useFactory: () => {
-                const commandRegistry = inject(AXPCommandRegistry);
-                const queryRegistry = inject(AXPQueryRegistry);
-                const entityService = inject(AXPEntityService);
-                for (const entityKey of entityKeys) {
-                    const dataAccessor = entityService.withEntity(entityKey).data();
-                    // Register Commands
-                    commandRegistry.register(`${entityKey}:Create`, async () => ({
-                        execute: async (input) => {
-                            try {
-                                const id = await dataAccessor.create(input);
-                                const entity = await dataAccessor.byKey(id);
-                                if (!entity) {
-                                    throw new Error('Entity not found after creation');
-                                }
-                                return {
-                                    success: true,
-                                    data: entity,
-                                };
-                            }
-                            catch (error) {
-                                return {
-                                    success: false,
-                                    message: {
-                                        text: error instanceof Error ? error.message : 'Failed to create entity',
-                                    },
-                                };
-                            }
-                        }
-                    }));
-                    commandRegistry.register(`${entityKey}:Update`, async () => ({
-                        execute: async ({ id, ...rest }) => {
-                            try {
-                                const updated = await dataAccessor.update(id, rest);
-                                return {
-                                    success: true,
-                                    data: updated,
-                                };
-                            }
-                            catch (error) {
-                                return {
-                                    success: false,
-                                    message: {
-                                        text: error instanceof Error ? error.message : 'Failed to update entity',
-                                    },
-                                };
-                            }
-                        }
-                    }));
-                    commandRegistry.register(`${entityKey}:Delete`, async () => ({
-                        execute: async (id) => {
-                            try {
-                                await dataAccessor.delete(id);
-                                return {
-                                    success: true,
-                                };
-                            }
-                            catch (error) {
-                                return {
-                                    success: false,
-                                    message: {
-                                        text: error instanceof Error ? error.message : 'Failed to delete entity',
-                                    },
-                                };
-                            }
-                        }
-                    }));
-                    // Register Queries
-                    queryRegistry.register(`${entityKey}:GetById`, async () => ({
-                        fetch: (id) => dataAccessor.byKey(id)
-                    }));
-                    queryRegistry.register(`${entityKey}:GetList`, async () => ({
-                        fetch: (request) => dataAccessor.query(request)
-                    }));
-                    // Implement getRoots, getChildren, and getByCategory using query with appropriate filters
-                    queryRegistry.register(`${entityKey}:GetRoots`, async () => ({
-                        fetch: async (request) => {
-                            return await dataAccessor.query({
-                                skip: 0,
-                                take: 1000,
-                                filter: {
-                                    field: 'parentId',
-                                    operator: {
-                                        type: 'isEmpty',
-                                    },
-                                    value: true,
-                                },
-                            });
-                        }
-                    }));
-                    queryRegistry.register(`${entityKey}:GetChildren`, async () => ({
-                        fetch: async (request) => {
-                            const parentKey = request.parentKey ?? 'parentId';
-                            return await dataAccessor.query({
-                                skip: 0,
-                                take: 1000,
-                                filter: {
-                                    field: parentKey,
-                                    operator: {
-                                        type: 'equal',
-                                    },
-                                    value: request.parentId,
-                                },
-                            });
-                        }
-                    }));
-                    queryRegistry.register(`${entityKey}:GetByCategory`, async () => ({
-                        fetch: async (request) => {
-                            const categoryKey = request.categoryKey ?? 'categoryIds';
-                            return await dataAccessor.query({
-                                skip: 0,
-                                take: 1000,
-                                filter: {
-                                    field: categoryKey,
-                                    operator: {
-                                        type: 'contains',
-                                    },
-                                    value: request.categoryId,
-                                },
-                            });
-                        }
-                    }));
-                }
-                return true;
-            }
-        },
-        // {
-        //     provide: AXP_PERMISSION_DEFINITION_PROVIDER,
-        //     multi: true,
-        //     useFactory: () => {
-        //         const provider: AXPPermissionDefinitionProvider = {
-        //             define: async (context) => {
-        //                 for (const entityKey of entityKeys) {
-        //                     const group = entityKey.split('.')[0];
-        //                     context.addGroup(group, group)
-        //                         .addPermission(entityKey, entityKey)
-        //                         .addChild(`${entityKey}:Create`, `${entityKey}:Create`)
-        //                         .addChild(`${entityKey}:Update`, `${entityKey}:Update`)
-        //                         .addChild(`${entityKey}:Delete`, `${entityKey}:Delete`)
-        //                         .endPermission()
-        //                         .endGroup();
-        //                 }
-        //             }
-        //         }
-        //         return provider;
-        //     }
-        // },
-        // {
-        //     provide: AXP_ENTITY_CRUD_SETUP,
-        //     multi: true,
-        //     useFactory: () => {
-        //         return true;
-        //     }
-        // }
-    ]);
-}
+
+//#endregion
+//#region ----   Injection Token   ----
+const AXP_ENTITY_DEFINITION_CRUD_SERVICE = new InjectionToken('AXP_ENTITY_DEFINITION_CRUD_SERVICE', {
+    providedIn: null,
+    factory: () => null,
+});
+//#endregion
 
 //#region ----   Dependency Injection Tokens   ----
 /**
- * Injection token for schema-specific middleware extensions.
- *
- * Used for targeted middleware that applies only to schemas matching
- * specific patterns (name or regex). This enables fine-grained control
- * over which schemas receive which middleware.
+ * Targeted middleware extension (name or regex) for property resolution.
  */
-const AXP_SCHEMA_EXTENSION = new InjectionToken('AXP_SCHEMA_EXTENSION');
+const AXP_PROPERTY_EXTENSION = new InjectionToken('AXP_PROPERTY_EXTENSION');
 /**
- * Injection token for schema setup initialization.
- *
- * Used during application bootstrap to register schemas that are
- * known at build time. Multiple providers can use this token to
- * contribute schemas to the registry.
+ * Bootstrap hook: register property definitions known at build time.
  */
-const AXP_SCHEMA_SETUP = new InjectionToken('AXP_SCHEMA_SETUP');
+const AXP_PROPERTY_SETUP = new InjectionToken('AXP_PROPERTY_SETUP');
 /**
- * Injection token for schema middleware setup initialization.
- *
- * Used during application bootstrap to register global middleware
- * that applies to all schema resolutions. This enables centralized
- * schema processing logic.
+ * Bootstrap hook: register global middleware for every property resolution.
  */
-const AXP_SCHEMA_MIDDLEWARE_SETUP = new InjectionToken('AXP_SCHEMA_MIDDLEWARE_SETUP');
+const AXP_PROPERTY_MIDDLEWARE_SETUP = new InjectionToken('AXP_PROPERTY_MIDDLEWARE_SETUP');
 /**
- * Injection token for schema loader setup initialization.
- *
- * Used during application bootstrap to register schema loaders
- * that can provide schemas on-demand when they're not found in
- * the registry.
+ * Bootstrap hook: register on-demand property loaders.
  */
-const AXP_SCHEMA_LOADER_SETUP = new InjectionToken('AXP_SCHEMA_LOADER_SETUP');
+const AXP_PROPERTY_LOADER_SETUP = new InjectionToken('AXP_PROPERTY_LOADER_SETUP');
 //#endregion
 
 //#region ----   Dependency Injection Tokens   ----
@@ -240,15 +75,11 @@ class AXPDomainModule {
     constructor() {
         this._commandSetup = inject(AXP_ENTITY_CRUD_SETUP, { optional: true });
         /**
-         * Injection token for schema setup initialization.
-         *
-         * Used during application bootstrap to register global middleware
-         * that applies to all schema resolutions. This enables centralized
-         * schema processing logic.
+         * Optional bootstrap hooks for registered property definitions (see {@link AXP_PROPERTY_SETUP} and related tokens).
          */
-        this._schemaSetup = inject(AXP_SCHEMA_SETUP, { optional: true });
-        this._schemaMiddlewareSetup = inject(AXP_SCHEMA_MIDDLEWARE_SETUP, { optional: true });
-        this._schemaLoaderSetup = inject(AXP_SCHEMA_LOADER_SETUP, { optional: true });
+        this._propertySetup = inject(AXP_PROPERTY_SETUP, { optional: true });
+        this._propertyMiddlewareSetup = inject(AXP_PROPERTY_MIDDLEWARE_SETUP, { optional: true });
+        this._propertyLoaderSetup = inject(AXP_PROPERTY_LOADER_SETUP, { optional: true });
         /**
          * Injection token for domain loader setup initialization.
          *
@@ -260,11 +91,11 @@ class AXPDomainModule {
         this._domainMiddlewareSetup = inject(AXP_DOMAIN_MIDDLEWARE_SETUP, { optional: true });
         this._domainSetup = inject(AXP_DOMAIN_SETUP, { optional: true });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -273,6 +104,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+var AXPDomainActionSide;
+(function (AXPDomainActionSide) {
+    AXPDomainActionSide["Client"] = "client";
+    AXPDomainActionSide["Server"] = "server";
+    AXPDomainActionSide["Both"] = "both";
+})(AXPDomainActionSide || (AXPDomainActionSide = {}));
 var AXPEntityCommandScope;
 (function (AXPEntityCommandScope) {
     AXPEntityCommandScope["TypeLevel"] = "typeLevel";
@@ -303,221 +140,31 @@ var AXPRelationshipCardinality;
     AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
 })(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
 
-//#region ----   AXPRelationModel   ----
-/**
- * Runtime model for relation definitions with parent references and helper methods
- */
-class AXPRelationModel {
-    constructor(definition, parent) {
-        console.log('Relation Model Constructor', definition, parent);
-        this.type = definition.type;
-        this.kind = definition.kind;
-        this.target = { ...definition.target };
-        this.source = { ...definition.source };
-        this.isRequired = definition.isRequired;
-        this.parent = parent;
-    }
-    //#endregion
-    //#region ----   Cardinality Methods   ----
-    /**
-     * Check if relation is one-to-one
-     */
-    isOneToOne() {
-        return this.type === AXPRelationshipCardinality.OneToOne;
-    }
-    /**
-     * Check if relation is one-to-many
-     */
-    isOneToMany() {
-        return this.type === AXPRelationshipCardinality.OneToMany;
-    }
-    /**
-     * Check if relation is many-to-many
-     */
-    isManyToMany() {
-        return this.type === AXPRelationshipCardinality.ManyToMany;
-    }
-    //#endregion
-    //#region ----   Kind Methods   ----
-    /**
-     * Check if relation is association
-     */
-    isAssociation() {
-        return this.kind === AXPRelationshipKind.Association;
-    }
-    /**
-     * Check if relation is composition
-     */
-    isComposition() {
-        return this.kind === AXPRelationshipKind.Composition;
-    }
-    /**
-     * Check if relation is aggregation
-     */
-    isAggregation() {
-        return this.kind === AXPRelationshipKind.Aggregation;
-    }
-    //#endregion
-    //#region ----   Navigation Methods   ----
-    /**
-     * Get parent aggregate
-     */
-    getAggregate() {
-        return this.parent;
-    }
-    /**
-     * Get parent module
-     */
-    getModule() {
-        return this.parent?.parent;
-    }
-    /**
-     * Get full path (module.aggregate.relation)
-     */
-    getPath() {
-        return `${this.parent.parent.name}.${this.parent.name}.${this.source.entity}->${this.target.entity}`;
-    }
-    //#endregion
-    //#region ----   Query Methods   ----
-    /**
-     * Get relation description
-     */
-    getDescription() {
-        const cardinalityDesc = this.getCardinalityDescription();
-        const kindDesc = this.getKindDescription();
-        const requiredDesc = this.isRequired ? 'required' : 'optional';
-        return `${cardinalityDesc} ${kindDesc} (${requiredDesc})`;
-    }
-    /**
-     * Get cardinality description
-     */
-    getCardinalityDescription() {
-        switch (this.type) {
-            case AXPRelationshipCardinality.OneToOne:
-                return 'one-to-one';
-            case AXPRelationshipCardinality.OneToMany:
-                return 'one-to-many';
-            case AXPRelationshipCardinality.ManyToMany:
-                return 'many-to-many';
-            default:
-                return 'unknown';
-        }
-    }
-    /**
-     * Get kind description
-     */
-    getKindDescription() {
-        switch (this.kind) {
-            case AXPRelationshipKind.Association:
-                return 'association';
-            case AXPRelationshipKind.Composition:
-                return 'composition';
-            case AXPRelationshipKind.Aggregation:
-                return 'aggregation';
-            default:
-                return 'unknown';
-        }
-    }
-    /**
-     * Get relation summary
-     */
-    getSummary() {
-        return `${this.source.entity}.${this.source.key} -> ${this.target.aggregate}.${this.target.entity}.${this.target.key}`;
-    }
-    //#endregion
-    //#region ----   Validation Methods   ----
-    /**
-     * Validate the relation structure
-     */
-    validate() {
-        const errors = [];
-        // Validate source
-        if (!this.source.entity)
-            errors.push('Source entity is required');
-        if (!this.source.key)
-            errors.push('Source key is required');
-        // Validate target
-        if (!this.target.aggregate)
-            errors.push('Target aggregate is required');
-        if (!this.target.entity)
-            errors.push('Target entity is required');
-        if (!this.target.key)
-            errors.push('Target key is required');
-        return errors;
-    }
-    //#endregion
-    //#region ----   Utility Methods   ----
-    /**
-     * Get relation characteristics
-     */
-    getCharacteristics() {
-        return {
-            type: this.getCardinalityDescription(),
-            kind: this.getKindDescription(),
-            required: this.isRequired,
-            isOwning: this.isComposition(),
-            isNavigable: !this.isComposition() || this.isOneToOne()
-        };
-    }
-    /**
-     * Check if relation involves entity
-     */
-    involvesEntity(entityName) {
-        return this.source.entity === entityName || this.target.entity === entityName;
-    }
-    /**
-     * Check if relation targets aggregate
-     */
-    targetsAggregate(aggregateName) {
-        return this.target.aggregate === aggregateName;
-    }
-    /**
-     * Get the other entity in the relation
-     */
-    getOtherEntity(entityName) {
-        if (this.source.entity === entityName) {
-            return this.target.entity;
-        }
-        else if (this.target.entity === entityName) {
-            return this.source.entity;
-        }
-        return null;
-    }
-    /**
-     * Convert back to interface definition
-     */
-    toDefinition() {
-        return {
-            type: this.type,
-            kind: this.kind,
-            target: { ...this.target },
-            source: { ...this.source },
-            isRequired: this.isRequired
-        };
-    }
-}
+//#region ----   Serializable menu definition (storage / CRUD contract)   ----
+//#endregion
+
+//#region ----   Serializable permission definition (storage / CRUD contract)   ----
+//#endregion
+
+//#endregion
+
+//#endregion
+
+//#region ---- Widget catalog persisted record ----
+//#endregion
 
 //#region ----   AXPAggregateModel   ----
 /**
  * Simple runtime model for aggregate definitions with parent references and navigation helpers.
- *
- * This model is a pure data structure that provides:
- * - Access to aggregate properties and metadata
- * - Navigation helpers for finding relations and entity references
- * - Parent module reference for hierarchy navigation
- *
- * All loading and resolution logic has been moved to AXPDomainRegistry.
+ * Relations are stored in a separate collection; join when needed.
  */
 class AXPAggregateModel {
     constructor(definition, parent) {
-        this.relations = [];
         this.name = definition.name;
         this.title = definition.title;
         this.validations = definition.validations || [];
         this.actions = definition.actions || [];
         this.parent = parent;
-        // Initialize relations with parent reference
-        this.relations = (definition.relations || []).map(relationDef => new AXPRelationModel(relationDef, this));
         // Extract entity references - convert all formats to simple string map
         this.entityReferences = this.extractEntityReferences(definition.entities);
     }
@@ -585,27 +232,6 @@ class AXPAggregateModel {
     hasEntity(entityName) {
         return entityName in this.entityReferences;
     }
-    /**
-     * Find relation by source and target entities
-     *
-     * @param sourceEntity Source entity name
-     * @param targetEntity Target entity name
-     * @returns Relation model or undefined if not found
-     */
-    findRelation(sourceEntity, targetEntity) {
-        return this.relations.find(relation => relation.source.entity === sourceEntity &&
-            relation.target.entity === targetEntity);
-    }
-    /**
-     * Get all relations for a specific entity
-     *
-     * @param entityName Entity name
-     * @returns Array of relations involving the entity
-     */
-    getEntityRelations(entityName) {
-        return this.relations.filter(relation => relation.source.entity === entityName ||
-            relation.target.entity === entityName);
-    }
     //#endregion
     //#region ----   Parent Navigation   ----
     /**
@@ -634,7 +260,6 @@ class AXPAggregateModel {
     getStatistics() {
         return {
             entityCount: Object.keys(this.entityReferences).length,
-            relationCount: this.relations.length,
             actionCount: this.actions.length,
             validationCount: this.validations.length
         };
@@ -649,7 +274,6 @@ class AXPAggregateModel {
             name: this.name,
             title: this.title,
             entities: this.entityReferences, // Return as reference map
-            relations: this.relations.map(relation => relation.toDefinition()),
             validations: this.validations,
             actions: this.actions
         };
@@ -668,13 +292,6 @@ class AXPAggregateModel {
             errors.push('Aggregate name is required');
         if (!this.title)
             errors.push('Aggregate title is required');
-        // Validate relations
-        this.relations.forEach(relation => {
-            const relationErrors = relation.validate();
-            if (relationErrors.length > 0) {
-                errors.push(...relationErrors.map(err => `Relation: ${err}`));
-            }
-        });
         // Validate entity references
         for (const [entityName, entityRef] of Object.entries(this.entityReferences)) {
             if (!entityRef || typeof entityRef !== 'string') {
@@ -795,18 +412,11 @@ class AXPModuleModel {
         return allReferences;
     }
     /**
-     * Get all relations across all aggregates
-     *
-     * @returns Array of all relation models
+     * Relations are stored in a separate collection. Use relation queries for join when needed.
+     * @deprecated Relations are no longer nested in aggregates.
      */
     getAllRelations() {
-        const allRelations = [];
-        for (const aggregate of this.aggregates) {
-            for (const relation of aggregate.relations) {
-                allRelations.push({ aggregate, relation });
-            }
-        }
-        return allRelations;
+        return [];
     }
     //#endregion
     //#region ----   Validation Methods   ----
@@ -837,135 +447,274 @@ class AXPModuleModel {
         }
         return errors;
     }
-    //#endregion
-    //#region ----   Utility Methods   ----
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get module statistics
+     *
+     * @returns Statistics object
+     */
+    getStatistics() {
+        const aggregateStats = this.aggregates.map(agg => agg.getStatistics());
+        return {
+            aggregateCount: this.aggregates.length,
+            entityCount: aggregateStats.reduce((sum, stat) => sum + stat.entityCount, 0),
+            actionCount: aggregateStats.reduce((sum, stat) => sum + stat.actionCount, 0),
+            validationCount: aggregateStats.reduce((sum, stat) => sum + stat.validationCount, 0)
+        };
+    }
+    /**
+     * Convert back to interface definition
+     *
+     * @returns Module definition
+     */
+    toDefinition() {
+        return {
+            name: this.name,
+            title: this.title,
+            aggregates: this.aggregates.map(agg => agg.toDefinition())
+        };
+    }
+}
+//#endregion
+
+//#region ----   AXPPropertyModel   ----
+/**
+ * Runtime model for a {@link AXPPropertyDefinition} with helper methods.
+ */
+class AXPPropertyModel {
+    constructor(definition) {
+        this.name = definition.name;
+        this.title = definition.title;
+        this.interface = definition.interface;
+        this.disabled = definition.disabled;
+        this.dataType = definition.dataType ?? 'string';
+        this.validations = definition.validations ?? [];
+        this.features = definition.features ?? {};
+        this.metadata = definition.metadata;
+        this.description = definition.description;
+        this.icon = definition.icon;
+        this.defaultValue = definition.defaultValue;
+    }
+    //#endregion
+    /**
+     * Get widget options
+     */
+    getWidgetOptions() {
+        return this.interface.options;
+    }
+    /**
+     * Check if the property is disabled
+     */
+    isDisabled() {
+        return this.disabled ?? false;
+    }
+    //#endregion
+    //#region ----   Feature Methods   ----
+    /**
+     * Check if searchable
+     */
+    isSearchable() {
+        return this.features.searchable?.enabled ?? false;
+    }
+    /**
+     * Check if full text searchable
+     */
+    isFullTextSearchable() {
+        return this.features.searchable?.fullText ?? false;
+    }
+    /**
+     * Check if filterable
+     */
+    isFilterable() {
+        return this.features.filterable?.enabled ?? false;
+    }
+    /**
+     * Check if inline filterable
+     */
+    isInlineFilterable() {
+        return this.features.filterable?.inline ?? false;
+    }
+    /**
+     * Check if sortable
+     */
+    isSortable() {
+        return this.features.sortable?.enabled ?? false;
+    }
+    /**
+     * Check if auditable
+     */
+    isAuditable() {
+        return this.features.auditable?.enabled ?? false;
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validate the property definition structure
+     */
+    async validate() {
+        const errors = [];
+        // Validate interface
+        if (!this.interface.name) {
+            errors.push('Widget type is required');
+        }
+        return errors;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get property capabilities
+     */
+    getCapabilities() {
+        return {
+            searchable: this.isSearchable(),
+            fullTextSearchable: this.isFullTextSearchable(),
+            filterable: this.isFilterable(),
+            inlineFilterable: this.isInlineFilterable(),
+            sortable: this.isSortable(),
+            auditable: this.isAuditable(),
+            disabled: this.isDisabled()
+        };
+    }
     /**
-     * Get module statistics
-     *
-     * @returns Statistics object
+     * Get property summary
      */
-    getStatistics() {
-        const aggregateStats = this.aggregates.map(agg => agg.getStatistics());
+    getSummary() {
+        const capabilities = this.getCapabilities();
+        const capabilityCount = Object.values(capabilities).filter(Boolean).length;
         return {
-            aggregateCount: this.aggregates.length,
-            entityCount: aggregateStats.reduce((sum, stat) => sum + stat.entityCount, 0),
-            relationCount: aggregateStats.reduce((sum, stat) => sum + stat.relationCount, 0),
-            actionCount: aggregateStats.reduce((sum, stat) => sum + stat.actionCount, 0),
-            validationCount: aggregateStats.reduce((sum, stat) => sum + stat.validationCount, 0)
+            widget: this.interface.name,
+            hasOptions: !!this.interface.options,
+            hasMetadata: !!this.metadata,
+            hasValidations: !!this.validations && this.validations.length > 0,
+            capabilityCount
         };
     }
     /**
      * Convert back to interface definition
-     *
-     * @returns Module definition
      */
     toDefinition() {
         return {
             name: this.name,
             title: this.title,
-            aggregates: this.aggregates.map(agg => agg.toDefinition())
+            description: this.description,
+            icon: this.icon,
+            dataType: this.dataType,
+            defaultValue: this.defaultValue,
+            disabled: this.disabled,
+            interface: this.interface,
+            validations: this.validations,
+            features: this.features,
+            metadata: this.metadata
         };
     }
 }
-//#endregion
 
+//#region ----   Property definition helpers   ----
+/**
+ * Strips entity-only fields so the payload matches {@link AXPPropertyDefinition}.
+ */
+function toPropertyDefinition(def) {
+    const { actions, fieldFeatures, ...propertyDefinition } = def;
+    return propertyDefinition;
+}
+//#endregion
 //#region ----   AXPEntityFieldModel   ----
 /**
  * Runtime model for entity field definitions with parent references and helper methods
  */
 class AXPEntityFieldModel {
-    constructor(definition, parent, schemaService) {
+    constructor(definition, parent, propertyService) {
+        this.entityPropertyDefinition = definition;
         this.name = definition.name;
         this.title = definition.title;
         this.description = definition.description;
         this.validations = definition.validations;
         this.actions = definition.actions;
-        this.features = definition.features;
+        this.fieldFeatures = definition.fieldFeatures;
         this.defaultValue = definition.defaultValue;
         this.parent = parent;
-        this.schemaService = schemaService;
-        // Store schema name for toDefinition
-        this.schemaName = definition.schema;
-        // Resolve schema by name from schema service
-        this.schema = schemaService.resolveSync(definition.schema);
+        this.propertyService = propertyService;
+        this.property = new AXPPropertyModel(toPropertyDefinition(definition));
+        this.propertyName = definition.name;
     }
-    //#endregion
     //#region ----   Feature Check Methods   ----
     /**
      * Check if field is nullable
      */
     isNullable() {
-        return this.features?.nullable ?? false;
+        return this.fieldFeatures?.nullable ?? false;
     }
     /**
      * Check if field is readonly
      */
     isReadonly() {
-        return this.features?.readOnly ?? false;
+        return this.fieldFeatures?.readOnly ?? false;
     }
     /**
      * Check if field is required (has required validation)
      */
     isRequired() {
-        return this.validations?.some(validation => validation.rule === 'required') ?? false;
+        return this.validations?.some((validation) => validation.rule === "required") ?? false;
     }
     /**
      * Check if field is searchable
      */
     isSearchable() {
-        return this.schema.features?.searchable?.enabled ?? false;
+        return this.property.features?.searchable?.enabled ?? false;
     }
     /**
      * Check if field supports full text search
      */
     isFullTextSearchable() {
-        return this.schema.features?.searchable?.fullText ?? false;
+        return this.property.features?.searchable?.fullText ?? false;
     }
     /**
      * Check if field is filterable
      */
     isFilterable() {
-        return this.schema.features?.filterable?.enabled ?? false;
+        return this.property.features?.filterable?.enabled ?? false;
     }
     /**
      * Check if field has inline filtering
      */
     hasInlineFiltering() {
-        return this.schema.features?.filterable?.inline ?? false;
+        return this.property.features?.filterable?.inline ?? false;
     }
     /**
      * Check if field is sortable
      */
     isSortable() {
-        return this.schema.features?.sortable?.enabled ?? false;
+        return this.property.features?.sortable?.enabled ?? false;
     }
     /**
      * Check if field is auditable
      */
     isAuditable() {
-        return this.schema.features?.auditable?.enabled ?? false;
+        return this.property.features?.auditable?.enabled ?? false;
     }
     //#endregion
-    //#region ----   Schema Methods   ----
+    //#region ----   Property info   ----
     /**
-     * Get the schema name
+     * Registered property name (same as entity field name in the embedded model).
      */
-    getSchemaName() {
-        return this.schemaName;
+    getPropertyName() {
+        return this.propertyName;
     }
     /**
-     * Get schema info from registry
+     * Registration metadata when this field's definition name is registered; otherwise embedded summary.
      */
-    getSchemaInfo() {
-        return this.schemaService.getSchemaInfo(this.schemaName);
+    getPropertyInfo() {
+        if (this.propertyService.isRegistered(this.property.name)) {
+            return this.propertyService.getRegisteredProperty(this.property.name);
+        }
+        return this.property.getSummary();
     }
     /**
-     * Re-resolve schema from registry (useful after schema updates)
+     * Rebuild the property model from embedded definition (e.g. after definition updates).
      */
-    refreshSchema() {
-        const newSchema = this.schemaService.resolveSync(this.schemaName);
-        this.schema = newSchema;
-        this.schema.parent = this;
+    refreshProperty() {
+        this.property = new AXPPropertyModel(toPropertyDefinition(this.entityPropertyDefinition));
     }
     //#endregion
     //#region ----   Navigation Methods   ----
@@ -1000,25 +749,17 @@ class AXPEntityFieldModel {
      */
     async validate() {
         const errors = [];
-        // Validate field structure
         if (!this.name)
-            errors.push('Field name is required');
+            errors.push("Field name is required");
         if (!this.title)
-            errors.push('Field title is required');
-        // Validate schema name
-        if (!this.schemaName) {
-            errors.push('Schema name is required');
-        }
-        else {
-            if (!this.schemaService.isRegistered(this.schemaName)) {
-                errors.push(`Schema '${this.schemaName}' is not registered`);
-            }
-        }
-        // Validate schema if it exists
-        if (this.schema) {
-            const schemaErrors = await this.schema.validate();
-            if (schemaErrors.length > 0) {
-                errors.push(...schemaErrors.map(err => `Schema: ${err}`));
+            errors.push("Field title is required");
+        if (!this.property.interface?.name) {
+            errors.push("Widget type (interface.name) is required");
+        }
+        if (this.property) {
+            const propertyErrors = await this.property.validate();
+            if (propertyErrors.length > 0) {
+                errors.push(...propertyErrors.map((err) => `Property: ${err}`));
             }
         }
         return errors;
@@ -1032,10 +773,10 @@ class AXPEntityFieldModel {
         return {
             hasValidations: !!this.validations && this.validations.length > 0,
             hasActions: !!this.actions && this.actions.length > 0,
-            hasFeatures: !!this.features,
+            hasFieldFeatures: !!this.fieldFeatures,
             hasDefaultValue: this.defaultValue !== undefined,
             validationCount: this.validations?.length ?? 0,
-            actionCount: this.actions?.length ?? 0
+            actionCount: this.actions?.length ?? 0,
         };
     }
     /**
@@ -1049,7 +790,7 @@ class AXPEntityFieldModel {
             auditable: this.isAuditable(),
             nullable: this.isNullable(),
             readonly: this.isReadonly(),
-            required: this.isRequired()
+            required: this.isRequired(),
         };
     }
     /**
@@ -1057,32 +798,28 @@ class AXPEntityFieldModel {
      */
     toDefinition() {
         return {
-            name: this.name,
-            title: this.title,
-            description: this.description,
-            validations: this.validations,
+            ...this.property.toDefinition(),
             actions: this.actions,
-            features: this.features,
-            defaultValue: this.defaultValue,
-            schema: this.schemaName
+            fieldFeatures: this.fieldFeatures,
         };
     }
 }
+//#endregion
 
 //#region ----   AXPEntityModel   ----
 /**
  * Runtime model for entity definitions with parent references and helper methods
  */
 class AXPEntityModel {
-    constructor(definition, parent, schemaService) {
+    constructor(definition, parent, propertyService) {
         this.fields = [];
         this.name = definition.name;
         this.title = definition.title;
         this.type = definition.type;
         this.parent = parent;
-        this.schemaService = schemaService;
-        // Initialize fields with parent reference and schema service
-        this.fields = definition.fields.map(fieldDef => new AXPEntityFieldModel(fieldDef, this, schemaService));
+        this.propertyService = propertyService;
+        // Initialize fields with parent reference and property service
+        this.fields = definition.fields.map(fieldDef => new AXPEntityFieldModel(fieldDef, this, propertyService));
     }
     //#endregion
     //#region ----   Query Methods   ----
@@ -1098,12 +835,6 @@ class AXPEntityModel {
     getAllFields() {
         return [...this.fields];
     }
-    /**
-     * Get fields by data type
-     */
-    getFieldsByType(dataType) {
-        return this.fields.filter(field => field.schema.dataType === dataType);
-    }
     /**
      * Get required fields
      */
@@ -1223,181 +954,196 @@ class AXPEntityModel {
     }
 }
 
-//#region ----   AXPSchemaModel   ----
+//#region ----   AXPRelationModel   ----
 /**
- * Runtime model for schema definitions with helper methods
+ * Runtime model for standalone relation definitions.
+ * Relations live in their own collection; join when needed.
  */
-class AXPSchemaModel {
-    constructor(definition) {
-        this.name = definition.name;
-        this.dataType = definition.dataType;
-        this.interface = definition.interface;
-        this.validations = definition.validations ?? [];
-        this.features = definition.features ?? {};
-        this.metadata = definition.metadata;
+class AXPRelationModel {
+    constructor(definition, parent) {
+        this.type = definition.type;
+        this.kind = definition.kind;
+        this.target = { ...definition.target };
+        this.source = { ...definition.source };
+        this.isRequired = definition.isRequired;
+        this.parent = parent;
     }
     //#endregion
-    //#region ----   Data Type Methods   ----
-    /**
-     * Check if schema is for string data
-     */
-    isString() {
-        return this.dataType === 'string';
-    }
+    //#region ----   Cardinality Methods   ----
     /**
-     * Check if schema is for number data
+     * Check if relation is one-to-one
      */
-    isNumber() {
-        return this.dataType === 'number';
+    isOneToOne() {
+        return this.type === AXPRelationshipCardinality.OneToOne;
     }
     /**
-     * Check if schema is for boolean data
+     * Check if relation is one-to-many
      */
-    isBoolean() {
-        return this.dataType === 'boolean';
+    isOneToMany() {
+        return this.type === AXPRelationshipCardinality.OneToMany;
     }
     /**
-     * Check if schema is for date data
+     * Check if relation is many-to-many
      */
-    isDate() {
-        return this.dataType === 'date';
+    isManyToMany() {
+        return this.type === AXPRelationshipCardinality.ManyToMany;
     }
+    //#endregion
+    //#region ----   Kind Methods   ----
     /**
-     * Check if schema is for object data
+     * Check if relation is association
      */
-    isObject() {
-        return this.dataType === 'object';
+    isAssociation() {
+        return this.kind === AXPRelationshipKind.Association;
     }
     /**
-     * Check if schema is for array data
+     * Check if relation is composition
      */
-    isArray() {
-        return this.dataType === 'array';
+    isComposition() {
+        return this.kind === AXPRelationshipKind.Composition;
     }
     /**
-     * Check if schema is for blob data
+     * Check if relation is aggregation
      */
-    isBlob() {
-        return this.dataType === 'blob';
+    isAggregation() {
+        return this.kind === AXPRelationshipKind.Aggregation;
     }
     //#endregion
-    //#region ----   Interface Methods   ----
+    //#region ----   Navigation Methods   ----
     /**
-     * Get widget type
+     * Get parent aggregate
      */
-    getWidgetType() {
-        return this.interface.widget;
+    getAggregate() {
+        return this.parent;
     }
     /**
-     * Get widget options
+     * Get parent module
      */
-    getWidgetOptions() {
-        return this.interface.options;
+    getModule() {
+        return this.parent?.parent;
     }
     /**
-     * Check if interface is disabled
+     * Get full path (module.aggregate.relation)
      */
-    isDisabled() {
-        return this.interface.disabled ?? false;
+    getPath() {
+        return `${this.parent.parent.name}.${this.parent.name}.${this.source.entity}->${this.target.entity}`;
     }
     //#endregion
-    //#region ----   Feature Methods   ----
-    /**
-     * Check if searchable
-     */
-    isSearchable() {
-        return this.features.searchable?.enabled ?? false;
-    }
-    /**
-     * Check if full text searchable
-     */
-    isFullTextSearchable() {
-        return this.features.searchable?.fullText ?? false;
-    }
+    //#region ----   Query Methods   ----
     /**
-     * Check if filterable
+     * Get relation description
      */
-    isFilterable() {
-        return this.features.filterable?.enabled ?? false;
+    getDescription() {
+        const cardinalityDesc = this.getCardinalityDescription();
+        const kindDesc = this.getKindDescription();
+        const requiredDesc = this.isRequired ? 'required' : 'optional';
+        return `${cardinalityDesc} ${kindDesc} (${requiredDesc})`;
     }
     /**
-     * Check if inline filterable
+     * Get cardinality description
      */
-    isInlineFilterable() {
-        return this.features.filterable?.inline ?? false;
+    getCardinalityDescription() {
+        switch (this.type) {
+            case AXPRelationshipCardinality.OneToOne:
+                return 'one-to-one';
+            case AXPRelationshipCardinality.OneToMany:
+                return 'one-to-many';
+            case AXPRelationshipCardinality.ManyToMany:
+                return 'many-to-many';
+            default:
+                return 'unknown';
+        }
     }
     /**
-     * Check if sortable
+     * Get kind description
      */
-    isSortable() {
-        return this.features.sortable?.enabled ?? false;
+    getKindDescription() {
+        switch (this.kind) {
+            case AXPRelationshipKind.Association:
+                return 'association';
+            case AXPRelationshipKind.Composition:
+                return 'composition';
+            case AXPRelationshipKind.Aggregation:
+                return 'aggregation';
+            default:
+                return 'unknown';
+        }
     }
     /**
-     * Check if auditable
+     * Get relation summary
      */
-    isAuditable() {
-        return this.features.auditable?.enabled ?? false;
+    getSummary() {
+        return `${this.source.entity}.${this.source.key} -> ${this.target.aggregate}.${this.target.entity}.${this.target.key}`;
     }
     //#endregion
     //#region ----   Validation Methods   ----
     /**
-     * Validate the schema structure
+     * Validate the relation structure
      */
-    async validate() {
+    validate() {
         const errors = [];
-        // Validate data type
-        const validDataTypes = ['string', 'number', 'boolean', 'date', 'object', 'array', 'blob'];
-        if (!validDataTypes.includes(this.dataType)) {
-            errors.push(`Invalid data type: ${this.dataType}`);
-        }
-        // Validate interface
-        if (!this.interface.widget) {
-            errors.push('Widget type is required');
-        }
+        // Validate source
+        if (!this.source.entity)
+            errors.push('Source entity is required');
+        if (!this.source.key)
+            errors.push('Source key is required');
+        // Validate target
+        if (!this.target.aggregate)
+            errors.push('Target aggregate is required');
+        if (!this.target.entity)
+            errors.push('Target entity is required');
+        if (!this.target.key)
+            errors.push('Target key is required');
         return errors;
     }
     //#endregion
     //#region ----   Utility Methods   ----
     /**
-     * Get schema capabilities
+     * Get relation characteristics
      */
-    getCapabilities() {
+    getCharacteristics() {
         return {
-            searchable: this.isSearchable(),
-            fullTextSearchable: this.isFullTextSearchable(),
-            filterable: this.isFilterable(),
-            inlineFilterable: this.isInlineFilterable(),
-            sortable: this.isSortable(),
-            auditable: this.isAuditable(),
-            disabled: this.isDisabled()
+            type: this.getCardinalityDescription(),
+            kind: this.getKindDescription(),
+            required: this.isRequired,
+            isOwning: this.isComposition(),
+            isNavigable: !this.isComposition() || this.isOneToOne()
         };
     }
     /**
-     * Get schema summary
+     * Check if relation involves entity
      */
-    getSummary() {
-        const capabilities = this.getCapabilities();
-        const capabilityCount = Object.values(capabilities).filter(Boolean).length;
-        return {
-            dataType: this.dataType,
-            widget: this.getWidgetType(),
-            hasOptions: !!this.interface.options,
-            hasMetadata: !!this.metadata,
-            hasValidations: !!this.validations && this.validations.length > 0,
-            capabilityCount
-        };
+    involvesEntity(entityName) {
+        return this.source.entity === entityName || this.target.entity === entityName;
     }
     /**
-     * Convert back to interface definition
+     * Check if relation targets aggregate
+     */
+    targetsAggregate(aggregateName) {
+        return this.target.aggregate === aggregateName;
+    }
+    /**
+     * Get the other entity in the relation
+     */
+    getOtherEntity(entityName) {
+        if (this.source.entity === entityName) {
+            return this.target.entity;
+        }
+        else if (this.target.entity === entityName) {
+            return this.source.entity;
+        }
+        return null;
+    }
+    /**
+     * Convert back to interface definition (AXPRelationDefinition with full source/target)
      */
     toDefinition() {
         return {
-            name: this.name,
-            dataType: this.dataType,
-            interface: this.interface,
-            validations: this.validations,
-            features: this.features,
-            metadata: this.metadata
+            type: this.type,
+            kind: this.kind,
+            target: { ...this.target },
+            source: { ...this.source },
+            isRequired: this.isRequired
         };
     }
 }
@@ -1471,10 +1217,10 @@ class AXPModuleHelper {
         return [];
     }
     /**
-     * @deprecated Use AXPDomainService with field schema queries instead
+     * @deprecated Use AXPDomainService with registered property name queries instead
      */
-    static findFieldsBySchema(module, schemaName) {
-        console.warn('AXPModuleHelper.findFieldsBySchema is deprecated. Use AXPDomainService instead.');
+    static findFieldsByRegisteredPropertyName(module, propertyName) {
+        console.warn('AXPModuleHelper.findFieldsByRegisteredPropertyName is deprecated. Use AXPDomainService instead.');
         return [];
     }
     /**
@@ -1545,23 +1291,23 @@ class AXPModuleHelper {
  * }
  * ```
  */
-class AXPSchemaMiddlewareContext {
-    constructor(schema) {
-        // Deep clone to avoid mutating the original schema
-        this._schema = JSON.parse(JSON.stringify(schema));
+class AXPPropertyMiddlewareContext {
+    constructor(definition) {
+        // Deep clone to avoid mutating the original definition
+        this._definition = JSON.parse(JSON.stringify(definition));
     }
     //#region ----   Schema Access Properties   ----
     /**
      * Get the current schema definition (readonly access)
      */
-    get schema() {
-        return this._schema;
+    get definition() {
+        return this._definition;
     }
     /**
      * Get the schema name for conditional logic
      */
     get name() {
-        return this._schema.name;
+        return this._definition.name;
     }
     //#endregion
     //#region ----   Default Value Management   ----
@@ -1570,18 +1316,18 @@ class AXPSchemaMiddlewareContext {
      * @param defaultValue The default value to set
      */
     withDefaultValue(defaultValue) {
-        if (!this._schema.interface.options) {
-            this._schema.interface.options = {};
+        if (!this._definition.interface.options) {
+            this._definition.interface.options = {};
         }
-        this._schema.interface.options['defaultValue'] = defaultValue;
+        this._definition.interface.options['defaultValue'] = defaultValue;
         return this;
     }
     /**
      * Remove the default value from the widget
      */
     removeDefaultValue() {
-        if (this._schema.interface.options) {
-            delete this._schema.interface.options['defaultValue'];
+        if (this._definition.interface.options) {
+            delete this._definition.interface.options['defaultValue'];
         }
         return this;
     }
@@ -1592,10 +1338,10 @@ class AXPSchemaMiddlewareContext {
      * @param rules Array of validation rules to add
      */
     withValidation(rules) {
-        if (!this._schema.validations) {
-            this._schema.validations = [];
+        if (!this._definition.validations) {
+            this._definition.validations = [];
         }
-        this._schema.validations.push(...rules);
+        this._definition.validations.push(...rules);
         return this;
     }
     /**
@@ -1603,10 +1349,10 @@ class AXPSchemaMiddlewareContext {
      * @param rule The validation rule to add
      */
     addValidation(rule) {
-        if (!this._schema.validations) {
-            this._schema.validations = [];
+        if (!this._definition.validations) {
+            this._definition.validations = [];
         }
-        this._schema.validations.push(rule);
+        this._definition.validations.push(rule);
         return this;
     }
     /**
@@ -1620,7 +1366,7 @@ class AXPSchemaMiddlewareContext {
      * Remove all validation rules from the schema
      */
     clearValidations() {
-        this._schema.validations = [];
+        this._definition.validations = [];
         return this;
     }
     /**
@@ -1628,8 +1374,8 @@ class AXPSchemaMiddlewareContext {
      * @param ruleName The name of the rule to remove (e.g., 'required', 'email')
      */
     removeValidation(ruleName) {
-        if (this._schema.validations) {
-            this._schema.validations = this._schema.validations.filter(v => v.rule !== ruleName);
+        if (this._definition.validations) {
+            this._definition.validations = this._definition.validations.filter((v) => v.rule !== ruleName);
         }
         return this;
     }
@@ -1640,8 +1386,9 @@ class AXPSchemaMiddlewareContext {
      * @param options Object containing widget-specific options to merge
      */
     withWidgetOptions(options) {
-        this._schema.interface.options = {
-            ...this._schema.interface.options,
+        const current = this._definition.interface.options ?? {};
+        this._definition.interface.options = {
+            ...current,
             ...options
         };
         return this;
@@ -1651,8 +1398,8 @@ class AXPSchemaMiddlewareContext {
      * @param optionKey The key of the option to remove
      */
     removeWidgetOption(optionKey) {
-        if (this._schema.interface.options) {
-            delete this._schema.interface.options[optionKey];
+        if (this._definition.interface.options) {
+            delete this._definition.interface.options[optionKey];
         }
         return this;
     }
@@ -1661,7 +1408,7 @@ class AXPSchemaMiddlewareContext {
      * @param widgetType The new widget type identifier
      */
     withWidgetType(widgetType) {
-        this._schema.interface.widget = widgetType;
+        this._definition.interface.name = widgetType;
         return this;
     }
     //#endregion
@@ -1671,8 +1418,8 @@ class AXPSchemaMiddlewareContext {
      * @param features Object containing feature configurations to merge
      */
     withFeatures(features) {
-        this._schema.features = {
-            ...this._schema.features,
+        this._definition.features = {
+            ...this._definition.features,
             ...features
         };
         return this;
@@ -1683,10 +1430,10 @@ class AXPSchemaMiddlewareContext {
      * @param fullText Whether full-text search is enabled
      */
     searchable(enabled = true, fullText = false) {
-        if (!this._schema.features) {
-            this._schema.features = {};
+        if (!this._definition.features) {
+            this._definition.features = {};
         }
-        this._schema.features.searchable = { enabled, fullText };
+        this._definition.features.searchable = { enabled, fullText };
         return this;
     }
     /**
@@ -1695,10 +1442,10 @@ class AXPSchemaMiddlewareContext {
      * @param inline Whether inline filtering is supported
      */
     filterable(enabled = true, inline = false) {
-        if (!this._schema.features) {
-            this._schema.features = {};
+        if (!this._definition.features) {
+            this._definition.features = {};
         }
-        this._schema.features.filterable = { enabled, inline };
+        this._definition.features.filterable = { enabled, inline };
         return this;
     }
     /**
@@ -1706,10 +1453,10 @@ class AXPSchemaMiddlewareContext {
      * @param enabled Whether sorting is enabled
      */
     sortable(enabled = true) {
-        if (!this._schema.features) {
-            this._schema.features = {};
+        if (!this._definition.features) {
+            this._definition.features = {};
         }
-        this._schema.features.sortable = { enabled };
+        this._definition.features.sortable = { enabled };
         return this;
     }
     //#endregion
@@ -1719,8 +1466,8 @@ class AXPSchemaMiddlewareContext {
      * @param metadata Object containing metadata to merge
      */
     withMetadata(metadata) {
-        this._schema.metadata = {
-            ...this._schema.metadata,
+        this._definition.metadata = {
+            ...this._definition.metadata,
             ...metadata
         };
         return this;
@@ -1730,29 +1477,19 @@ class AXPSchemaMiddlewareContext {
      * @param key The metadata key to remove
      */
     removeMetadata(key) {
-        if (this._schema.metadata) {
-            delete this._schema.metadata[key];
+        if (this._definition.metadata) {
+            delete this._definition.metadata[key];
         }
         return this;
     }
     //#endregion
-    //#region ----   Schema Properties   ----
-    /**
-     * Set the data type for this schema
-     * @param dataType The new data type (string, number, boolean, etc.)
-     */
-    withDataType(dataType) {
-        this._schema.dataType = dataType;
-        return this;
-    }
-    //#endregion
     //#region ----   UI State Management   ----
     /**
      * Set the disabled state of the widget
      * @param isDisabled Whether the widget should be disabled
      */
     disabled(isDisabled = true) {
-        this._schema.interface.disabled = isDisabled;
+        this._definition.disabled = isDisabled;
         return this;
     }
     /**
@@ -1760,10 +1497,10 @@ class AXPSchemaMiddlewareContext {
      * @param visible Whether the widget should be visible
      */
     withVisibility(visible) {
-        if (!this._schema.interface.options) {
-            this._schema.interface.options = {};
+        if (!this._definition.interface.options) {
+            this._definition.interface.options = {};
         }
-        this._schema.interface.options['visible'] = visible;
+        this._definition.interface.options['visible'] = visible;
         return this;
     }
     /**
@@ -1771,10 +1508,10 @@ class AXPSchemaMiddlewareContext {
      * @param isReadonly Whether the widget should be readonly
      */
     readonly(isReadonly = true) {
-        if (!this._schema.interface.options) {
-            this._schema.interface.options = {};
+        if (!this._definition.interface.options) {
+            this._definition.interface.options = {};
         }
-        this._schema.interface.options['readonly'] = isReadonly;
+        this._definition.interface.options['readonly'] = isReadonly;
         return this;
     }
 }
@@ -1792,9 +1529,9 @@ class AXPSchemaMiddlewareContext {
  * - On-demand schema loading
  * - Caching and performance optimization
  */
-class AXPSchemaRegistry {
+class AXPPropertyRegistry {
     constructor() {
-        this._schemas = new Map();
+        this._registrations = new Map();
         this._globalMiddleware = [];
         this._modelCache = new Map();
         this._loaders = null;
@@ -1805,7 +1542,7 @@ class AXPSchemaRegistry {
      */
     register(definition, options = {}) {
         if (!definition.name || definition.name.trim() === '') {
-            throw new Error('Schema name is required and cannot be empty');
+            throw new Error('Property name is required and cannot be empty');
         }
         const registered = {
             name: definition.name,
@@ -1813,23 +1550,22 @@ class AXPSchemaRegistry {
             options,
             registeredAt: new Date()
         };
-        this._schemas.set(definition.name, registered);
+        this._registrations.set(definition.name, registered);
         this.invalidateCache(definition.name);
-        console.log(`Schema '${definition.name}' registered successfully`);
     }
     /**
      * Register multiple schemas at once for batch operations
      */
-    registerBatch(schemas) {
-        for (const schema of schemas) {
-            this.register(schema.definition, schema.options || {});
+    registerBatch(entries) {
+        for (const entry of entries) {
+            this.register(entry.definition, entry.options || {});
         }
     }
     /**
      * Remove a schema from the registry
      */
     unregister(name) {
-        const removed = this._schemas.delete(name);
+        const removed = this._registrations.delete(name);
         if (removed) {
             this.invalidateCache(name);
         }
@@ -1839,7 +1575,7 @@ class AXPSchemaRegistry {
      * Check if a schema is currently registered
      */
     isRegistered(name) {
-        return this._schemas.has(name);
+        return this._registrations.has(name);
     }
     //#endregion
     //#region ----   Resolution Methods   ----
@@ -1853,7 +1589,7 @@ class AXPSchemaRegistry {
             return this._modelCache.get(name);
         }
         // Try to get from registered schemas first
-        let registered = this._schemas.get(name);
+        let registered = this._registrations.get(name);
         // If not found, attempt on-demand loading
         if (!registered) {
             const definition = await this.loadFromLoaders(name);
@@ -1864,27 +1600,27 @@ class AXPSchemaRegistry {
                     options: {},
                     registeredAt: new Date()
                 };
-                this._schemas.set(name, registered);
+                this._registrations.set(name, registered);
             }
             else {
-                throw new Error(`Schema '${name}' is not registered and no loader can provide it`);
+                throw new Error(`Property '${name}' is not registered and no loader can provide it`);
             }
         }
         // Clone and process through middleware pipeline
-        const schema = this.cloneDefinition(registered.definition);
-        const context = new AXPSchemaMiddlewareContext(schema);
+        const definition = this.cloneDefinition(registered.definition);
+        const context = new AXPPropertyMiddlewareContext(definition);
         // Apply global middleware first
         for (const middleware of this._globalMiddleware) {
             await middleware(context);
         }
-        // Apply schema-specific middleware
+        // Apply registration-specific middleware
         if (registered.options.middleware) {
             for (const middleware of registered.options.middleware) {
                 await middleware(context);
             }
         }
         // Create final model and cache it
-        const model = new AXPSchemaModel(context.schema);
+        const model = new AXPPropertyModel(context.definition);
         this._modelCache.set(name, model);
         return model;
     }
@@ -1893,11 +1629,11 @@ class AXPSchemaRegistry {
      * Use only when middleware is not needed for performance.
      */
     resolveSync(name) {
-        const registered = this._schemas.get(name);
+        const registered = this._registrations.get(name);
         if (!registered) {
-            throw new Error(`Schema '${name}' is not registered`);
+            throw new Error(`Property '${name}' is not registered`);
         }
-        return new AXPSchemaModel(this.cloneDefinition(registered.definition));
+        return new AXPPropertyModel(this.cloneDefinition(registered.definition));
     }
     //#endregion
     //#region ----   Middleware Management   ----
@@ -1944,52 +1680,52 @@ class AXPSchemaRegistry {
      * Get all registered schema names
      */
     getRegisteredNames() {
-        return Array.from(this._schemas.keys());
+        return Array.from(this._registrations.keys());
     }
     /**
      * Get detailed registration information for a schema
      */
-    getSchemaInfo(name) {
-        return this._schemas.get(name);
+    getRegisteredProperty(name) {
+        return this._registrations.get(name);
     }
     /**
-     * Get all registered schemas with their metadata
+     * Get all registered properties with their metadata
      */
-    getAllSchemas() {
-        return Array.from(this._schemas.values());
+    getAllRegisteredProperties() {
+        return Array.from(this._registrations.values());
     }
     /**
-     * Find schemas by tag for categorization
+     * Find registered properties by tag for categorization
      */
     findByTag(tag) {
-        return Array.from(this._schemas.values()).filter(schema => schema.options.tags?.includes(tag));
+        return Array.from(this._registrations.values()).filter((registration) => registration.options.tags?.includes(tag));
     }
     /**
-     * Find schemas by widget type for widget-specific operations
+     * Find registered properties by widget type for widget-specific operations
      */
     findByWidget(widgetType) {
-        return Array.from(this._schemas.values()).filter(schema => schema.definition.interface.widget === widgetType);
+        return Array.from(this._registrations.values()).filter((registration) => registration.definition.interface.name === widgetType);
     }
     /**
      * Get comprehensive registry statistics
      */
     getStatistics() {
-        const schemasByWidget = {};
-        const schemasByTag = {};
-        for (const schema of this._schemas.values()) {
-            const widget = schema.definition.interface.widget;
-            schemasByWidget[widget] = (schemasByWidget[widget] || 0) + 1;
-            if (schema.options.tags) {
-                for (const tag of schema.options.tags) {
-                    schemasByTag[tag] = (schemasByTag[tag] || 0) + 1;
+        const propertiesByWidget = {};
+        const propertiesByTag = {};
+        for (const registration of this._registrations.values()) {
+            const widget = registration.definition.interface.name;
+            propertiesByWidget[widget] = (propertiesByWidget[widget] || 0) + 1;
+            if (registration.options.tags) {
+                for (const tag of registration.options.tags) {
+                    propertiesByTag[tag] = (propertiesByTag[tag] || 0) + 1;
                 }
             }
         }
         return {
-            schemaCount: this._schemas.size,
+            propertyCount: this._registrations.size,
             globalMiddlewareCount: this._globalMiddleware.length,
-            schemasByWidget,
-            schemasByTag
+            propertiesByWidget,
+            propertiesByTag
         };
     }
     //#endregion
@@ -2010,7 +1746,7 @@ class AXPSchemaRegistry {
      * Clear all registered schemas, middleware, and cached models
      */
     clear() {
-        this._schemas.clear();
+        this._registrations.clear();
         this._globalMiddleware.length = 0;
         this._modelCache.clear();
         this._loaders = null;
@@ -2027,7 +1763,7 @@ class AXPSchemaRegistry {
                 try {
                     const definition = await loader.load(name);
                     if (definition) {
-                        console.log(`Schema '${name}' loaded from ${loader.constructor.name}`);
+                        console.log(`Property '${name}' loaded from ${loader.constructor.name}`);
                         return definition;
                     }
                 }
@@ -2053,7 +1789,7 @@ class AXPSchemaRegistry {
                 });
             }
             catch (error) {
-                console.warn('Failed to initialize schema loaders:', error);
+                console.warn('Failed to initialize property loaders:', error);
                 this._loaders = [];
             }
         }
@@ -2065,90 +1801,89 @@ class AXPSchemaRegistry {
     cloneDefinition(definition) {
         return JSON.parse(JSON.stringify(definition));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaRegistry, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaRegistry, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyRegistry, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
-//#region ----   Schema Service   ----
+//#region ----   Property Service   ----
 /**
- * High-level facade service for schema operations.
+ * High-level facade for registered property definitions ({@link AXPPropertyDefinition}).
  *
- * Provides a simplified interface to the schema registry with additional
- * business logic and convenience methods for common operations.
+ * Wraps {@link AXPPropertyRegistry} with convenience methods for resolution and discovery.
  */
-class AXPSchemaService {
+class AXPPropertyService {
     constructor() {
-        this.registry = inject(AXPSchemaRegistry);
+        this.registry = inject(AXPPropertyRegistry);
     }
-    //#region ----   Core Schema Management   ----
+    //#region ----   Registration   ----
     /**
-     * Register a schema with optional configuration
+     * Register a property definition with optional configuration
      */
     register(definition, options) {
         this.registry.register(definition, options);
     }
     /**
-     * Register multiple schemas at once
+     * Register multiple property definitions at once
      */
-    registerBatch(schemas) {
-        this.registry.registerBatch(schemas);
+    registerBatch(entries) {
+        this.registry.registerBatch(entries);
     }
     /**
-     * Remove a schema from the registry
+     * Remove a property definition from the registry
      */
     unregister(name) {
         return this.registry.unregister(name);
     }
     /**
-     * Check if a schema is registered
+     * Check if a property definition is registered by name
      */
     isRegistered(name) {
         return this.registry.isRegistered(name);
     }
     /**
-     * Get all registered schema names
+     * Get all registered property names
      */
     getRegisteredNames() {
         return this.registry.getRegisteredNames();
     }
     /**
-     * Clear all schemas and reset the registry
+     * Clear all registrations and reset the registry
      */
     clear() {
         this.registry.clear();
     }
     //#endregion
-    //#region ----   Schema Resolution   ----
+    //#region ----   Resolution   ----
     /**
-     * Resolve a schema with full middleware processing
+     * Resolve a registered property by name with full middleware processing
      */
     async resolve(name) {
         return this.registry.resolve(name);
     }
     /**
-     * Resolve schema synchronously without middleware (for performance)
+     * Resolve synchronously without middleware (for performance)
      */
     resolveSync(name) {
         return this.registry.resolveSync(name);
     }
     /**
-     * Resolve multiple schemas for form building and batch operations
+     * Resolve multiple registered properties for form building and batch operations
      */
     async resolveMultiple(fieldConfigs) {
         const resolvedFields = await Promise.all(fieldConfigs.map(async (config) => ({
             name: config.name,
-            schema: await this.resolve(config.schemaName)
+            property: await this.resolve(config.propertyName),
         })));
         return resolvedFields;
     }
     //#endregion
     //#region ----   Middleware Management   ----
     /**
-     * Add global middleware that applies to all schema resolutions
+     * Add global middleware that applies to all property resolutions
      */
     addGlobalMiddleware(middleware) {
         this.registry.addGlobalMiddleware(middleware);
@@ -2168,25 +1903,25 @@ class AXPSchemaService {
     //#endregion
     //#region ----   Query and Discovery   ----
     /**
-     * Get detailed information about a registered schema
+     * Get detailed information about a registered property definition
      */
-    getSchemaInfo(name) {
-        return this.registry.getSchemaInfo(name);
+    getRegisteredProperty(name) {
+        return this.registry.getRegisteredProperty(name);
     }
     /**
-     * Get all registered schemas with their metadata
+     * Get all registered property definitions with their metadata
      */
-    getAllSchemas() {
-        return this.registry.getAllSchemas();
+    getAllRegisteredProperties() {
+        return this.registry.getAllRegisteredProperties();
     }
     /**
-     * Find schemas by tag for categorization and grouping
+     * Find registered properties by tag for categorization and grouping
      */
     findByTag(tag) {
         return this.registry.findByTag(tag);
     }
     /**
-     * Find schemas by widget type for widget-specific operations
+     * Find registered properties by widget type for widget-specific operations
      */
     findByWidget(widgetType) {
         return this.registry.findByWidget(widgetType);
@@ -2197,11 +1932,11 @@ class AXPSchemaService {
     getStatistics() {
         const stats = this.registry.getStatistics();
         // Enhance with top-used analytics
-        const mostUsedWidgets = Object.entries(stats.schemasByWidget)
+        const mostUsedWidgets = Object.entries(stats.propertiesByWidget)
             .sort(([, a], [, b]) => b - a)
             .slice(0, 5)
             .map(([widget]) => widget);
-        const mostUsedTags = Object.entries(stats.schemasByTag)
+        const mostUsedTags = Object.entries(stats.propertiesByTag)
             .sort(([, a], [, b]) => b - a)
             .slice(0, 5)
             .map(([tag]) => tag);
@@ -2214,24 +1949,24 @@ class AXPSchemaService {
     //#endregion
     //#region ----   Validation and Analysis   ----
     /**
-     * Validate that all referenced schemas exist in the registry
+     * Validate that all referenced property names exist in the registry
      */
-    validateSchemaReferences(schemaNames) {
-        const missingSchemas = [];
-        for (const schemaName of schemaNames) {
-            if (!this.isRegistered(schemaName)) {
-                missingSchemas.push(schemaName);
+    validatePropertyReferences(propertyNames) {
+        const missingPropertyNames = [];
+        for (const propertyName of propertyNames) {
+            if (!this.isRegistered(propertyName)) {
+                missingPropertyNames.push(propertyName);
             }
         }
         return {
-            valid: missingSchemas.length === 0,
-            missingSchemas
+            valid: missingPropertyNames.length === 0,
+            missingPropertyNames,
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPSchemaService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPPropertyService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2256,24 +1991,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * @example
  * ```typescript
  * // Simple loader registration
- * provideSchemaLoaders([
+ * providePropertyLoaders([
  *   HttpSchemaLoader,
  *   FileSystemSchemaLoader
  * ])
  *
  * // With priority configuration
- * provideSchemaLoaders([
+ * providePropertyLoaders([
  *   { loader: HttpSchemaLoader, priority: 10 },
  *   { loader: FileSystemSchemaLoader, priority: 5 }
  * ])
  * ```
  */
-function provideSchemaLoaders(loaders) {
+function providePropertyLoaders(loaders) {
     return makeEnvironmentProviders([
         {
-            provide: AXP_SCHEMA_LOADER_SETUP,
+            provide: AXP_PROPERTY_LOADER_SETUP,
             useFactory: async () => {
-                const registry = inject(AXPSchemaRegistry);
+                const registry = inject(AXPPropertyRegistry);
                 // Register each loader with the registry
                 for (const loader of loaders) {
                     const loaderClass = typeof loader === 'function' ? loader : loader.loader;
@@ -2300,7 +2035,7 @@ function provideSchemaLoaders(loaders) {
  *
  * @example
  * ```typescript
- * provideSchemaSetups([
+ * providePropertySetups([
  *   {
  *     definition: emailSchema,
  *     options: {
@@ -2315,15 +2050,14 @@ function provideSchemaLoaders(loaders) {
  * ])
  * ```
  */
-function provideSchemaSetups(schemas) {
+function providePropertySetups(entries) {
     return makeEnvironmentProviders([
         {
-            provide: AXP_SCHEMA_SETUP,
+            provide: AXP_PROPERTY_SETUP,
             useFactory: () => {
-                const registry = inject(AXPSchemaRegistry);
-                // Register all schemas with their options
-                for (const schema of schemas) {
-                    registry.register(schema.definition, schema.options);
+                const registry = inject(AXPPropertyRegistry);
+                for (const entry of entries) {
+                    registry.register(entry.definition, entry.options);
                 }
                 return true;
             },
@@ -2343,14 +2077,14 @@ function provideSchemaSetups(schemas) {
  *
  * @example
  * ```typescript
- * provideSchema(emailSchema, {
+ * provideProperty(emailSchema, {
  *   tags: ['user', 'contact'],
  *   description: 'User email field'
  * })
  * ```
  */
-function provideSchema(definition, options) {
-    return provideSchemaSetups([{ definition, options }]);
+function provideProperty(definition, options) {
+    return providePropertySetups([{ definition, options }]);
 }
 /**
  * Provide schema setups from a factory function for dynamic registration.
@@ -2363,7 +2097,7 @@ function provideSchema(definition, options) {
  *
  * @example
  * ```typescript
- * provideSchemasFromFactory(async () => {
+ * providePropertiesFromFactory(async () => {
  *   const config = await loadConfiguration();
  *   return config.schemas.map(schema => ({
  *     definition: schema,
@@ -2372,16 +2106,15 @@ function provideSchema(definition, options) {
  * })
  * ```
  */
-function provideSchemasFromFactory(schemaFactory) {
+function providePropertiesFromFactory(factory) {
     return makeEnvironmentProviders([
         {
-            provide: AXP_SCHEMA_SETUP,
+            provide: AXP_PROPERTY_SETUP,
             useFactory: async () => {
-                const registry = inject(AXPSchemaRegistry);
-                const schemas = await schemaFactory();
-                // Register all factory-generated schemas
-                for (const schema of schemas) {
-                    registry.register(schema.definition, schema.options);
+                const registry = inject(AXPPropertyRegistry);
+                const entries = await factory();
+                for (const entry of entries) {
+                    registry.register(entry.definition, entry.options);
                 }
                 return true;
             },
@@ -2405,16 +2138,16 @@ function provideSchemasFromFactory(schemaFactory) {
  * @example
  * ```typescript
  * // Global middleware
- * provideSchemaMiddleware([
+ * providePropertyMiddleware([
  *   (context) => {
- *     if (context.schema.dataType === 'string') {
+ *     if (context.definition.dataType === 'string') {
  *       context.searchable(true);
  *     }
  *   }
  * ])
  *
  * // Targeted middleware
- * provideSchemaMiddleware([
+ * providePropertyMiddleware([
  *   {
  *     target: /^user_/,
  *     middleware: (context) => context.withMetadata({ category: 'user' })
@@ -2422,7 +2155,7 @@ function provideSchemasFromFactory(schemaFactory) {
  * ])
  * ```
  */
-function provideSchemaMiddleware(middleware) {
+function providePropertyMiddleware(middleware) {
     const global = [];
     const targeted = [];
     // Separate global and targeted middleware for different processing
@@ -2437,9 +2170,9 @@ function provideSchemaMiddleware(middleware) {
     return makeEnvironmentProviders([
         // Setup global middleware that applies to all schemas
         ...(global.length > 0 ? [{
-                provide: AXP_SCHEMA_MIDDLEWARE_SETUP,
+                provide: AXP_PROPERTY_MIDDLEWARE_SETUP,
                 useFactory: () => {
-                    const registry = inject(AXPSchemaRegistry);
+                    const registry = inject(AXPPropertyRegistry);
                     for (const mw of global) {
                         registry.addGlobalMiddleware(mw);
                     }
@@ -2449,7 +2182,7 @@ function provideSchemaMiddleware(middleware) {
             }] : []),
         // Register targeted middleware entries for future extension support
         ...targeted.map(entry => ({
-            provide: AXP_SCHEMA_EXTENSION,
+            provide: AXP_PROPERTY_EXTENSION,
             useValue: entry,
             multi: true
         }))
@@ -2457,8 +2190,7 @@ function provideSchemaMiddleware(middleware) {
 }
 //#endregion
 
-//#region ----   Core Schema Registry   ----
-// Core registry and service classes
+//#region ----   Property registry core   ----
 //#endregion
 
 //#region ----   Domain Middleware Context   ----
@@ -2587,7 +2319,7 @@ class AXPDomainRegistry {
         // Registered loaders for on-demand loading
         this._loaders = [];
         // Injected dependencies
-        this.schemaService = inject(AXPSchemaService);
+        this.propertyService = inject(AXPPropertyService);
     }
     //#region ----   Main Resolution Method   ----
     /**
@@ -2772,7 +2504,6 @@ class AXPDomainRegistry {
                     name: pathInfo.aggregate,
                     title: pathInfo.aggregate || '',
                     entities: [definition],
-                    relations: [],
                     validations: [],
                     actions: []
                 };
@@ -2783,7 +2514,7 @@ class AXPDomainRegistry {
                 };
                 const entityModule = new AXPModuleModel(entityModuleDefinition);
                 const entityAggregate = new AXPAggregateModel(entityAggregateDefinition, entityModule);
-                return new AXPEntityModel(definition, entityAggregate, this.schemaService);
+                return new AXPEntityModel(definition, entityAggregate, this.propertyService);
             default:
                 throw new Error(`Unknown domain type: ${pathInfo.type}`);
         }
@@ -2813,10 +2544,10 @@ class AXPDomainRegistry {
             paths: Array.from(this._definitionCache.keys())
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainRegistry, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainRegistry, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainRegistry, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -3118,10 +2849,10 @@ class AXPDomainService {
             return module;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDomainService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDomainService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -3502,5 +3233,5 @@ function provideDomainMiddleware(config) {
  * Generated bundle index. Do not edit.
  */
 
-export { AXPAggregateModel, AXPDomainMiddlewareContext, AXPDomainModule, AXPDomainRegistry, AXPDomainService, AXPEntityCommandScope, AXPEntityFieldModel, AXPEntityModel, AXPEntityType, AXPModuleHelper, AXPModuleModel, AXPRelationModel, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaMiddlewareContext, AXPSchemaModel, AXPSchemaRegistry, AXPSchemaService, AXP_AGGREGATE_MIDDLEWARE_SETUP, AXP_ENTITY_CRUD_SETUP, AXP_ENTITY_MIDDLEWARE_SETUP, AXP_MODULE_MIDDLEWARE_SETUP, AXP_SCHEMA_EXTENSION, AXP_SCHEMA_LOADER_SETUP, AXP_SCHEMA_MIDDLEWARE_SETUP, AXP_SCHEMA_SETUP, provideAggregateMiddleware, provideDomainLoader, provideDomainLoaders, provideDomainMiddleware, provideEntity, provideEntityMiddleware, provideModuleMiddleware, provideSchema, provideSchemaLoaders, provideSchemaMiddleware, provideSchemaSetups, provideSchemasFromFactory };
+export { AXPAggregateModel, AXPDomainActionSide, AXPDomainMiddlewareContext, AXPDomainModule, AXPDomainRegistry, AXPDomainService, AXPEntityCommandScope, AXPEntityFieldModel, AXPEntityModel, AXPEntityType, AXPModuleHelper, AXPModuleModel, AXPPropertyMiddlewareContext, AXPPropertyModel, AXPPropertyRegistry, AXPPropertyService, AXPRelationModel, AXPRelationshipCardinality, AXPRelationshipKind, AXP_AGGREGATE_MIDDLEWARE_SETUP, AXP_ENTITY_CRUD_SETUP, AXP_ENTITY_DEFINITION_CRUD_SERVICE, AXP_ENTITY_MIDDLEWARE_SETUP, AXP_MODULE_MIDDLEWARE_SETUP, AXP_PROPERTY_EXTENSION, AXP_PROPERTY_LOADER_SETUP, AXP_PROPERTY_MIDDLEWARE_SETUP, AXP_PROPERTY_SETUP, provideAggregateMiddleware, provideDomainLoader, provideDomainLoaders, provideDomainMiddleware, provideEntityMiddleware, provideModuleMiddleware, providePropertiesFromFactory, provideProperty, providePropertyLoaders, providePropertyMiddleware, providePropertySetups, toPropertyDefinition };
 //# sourceMappingURL=acorex-platform-domain.mjs.map