@acorex/platform 20.8.12 → 20.8.14

package/fesm2022/acorex-platform-domain.mjs

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