@acorex/platform 20.0.6 → 20.0.8

package/fesm2022/acorex-platform-domain.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, makeEnvironmentProviders, inject, NgModule } from '@angular/core';
+import { InjectionToken, makeEnvironmentProviders, inject, NgModule, Injectable } from '@angular/core';
 import { AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
 import { AXPCommandRegistry, AXPQueryRegistry, AXPRuntimeModule } from '@acorex/platform/runtime';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
@@ -79,15 +79,105 @@ function provideEntity(entityKeys) {
     ]);
 }
 
+//#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.
+ */
+const AXP_SCHEMA_EXTENSION = new InjectionToken('AXP_SCHEMA_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.
+ */
+const AXP_SCHEMA_SETUP = new InjectionToken('AXP_SCHEMA_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.
+ */
+const AXP_SCHEMA_MIDDLEWARE_SETUP = new InjectionToken('AXP_SCHEMA_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.
+ */
+const AXP_SCHEMA_LOADER_SETUP = new InjectionToken('AXP_SCHEMA_LOADER_SETUP');
+//#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.
+ */
+const AXP_DOMAIN_EXTENSION = new InjectionToken('AXP_DOMAIN_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.
+ */
+const AXP_DOMAIN_SETUP = new InjectionToken('AXP_DOMAIN_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.
+ */
+const AXP_DOMAIN_MIDDLEWARE_SETUP = new InjectionToken('AXP_DOMAIN_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.
+ */
+const AXP_DOMAIN_LOADER_SETUP = new InjectionToken('AXP_DOMAIN_LOADER_SETUP');
+//#endregion
+
 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.
+         */
+        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.
+         *
+         * Used during application bootstrap to register domain loaders
+         * that can provide domain definitions on-demand when they're not found in
+         * the registry.
+         */
+        this._domainLoaderSetup = inject(AXP_DOMAIN_LOADER_SETUP, { optional: true });
+        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.0.4", ngImport: i0, type: AXPDomainModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.4", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainModule, imports: [AXPRuntimeModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: AXPDomainModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -96,11 +186,3234 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
                 }]
         }] });
 
-//export * from './lib/definitions.types';
+var AXPEntityCommandScope;
+(function (AXPEntityCommandScope) {
+    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
+    AXPEntityCommandScope["Selected"] = "selected";
+    AXPEntityCommandScope["Individual"] = "individual";
+    AXPEntityCommandScope["Section"] = "section";
+})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
+
+//#endregion
+
+var AXPEntityType;
+(function (AXPEntityType) {
+    AXPEntityType[AXPEntityType["Entity"] = 0] = "Entity";
+    AXPEntityType[AXPEntityType["AggregateRoot"] = 1] = "AggregateRoot";
+    AXPEntityType[AXPEntityType["ValueObject"] = 2] = "ValueObject";
+})(AXPEntityType || (AXPEntityType = {}));
+
+var AXPRelationshipKind;
+(function (AXPRelationshipKind) {
+    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
+    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
+    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
+})(AXPRelationshipKind || (AXPRelationshipKind = {}));
+var AXPRelationshipCardinality;
+(function (AXPRelationshipCardinality) {
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
+    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 ----   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.
+ */
+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);
+    }
+    //#endregion
+    //#region ----   Entity Reference Extraction   ----
+    /**
+     * Extract entity references from various entity definition formats
+     * and convert to simple string map
+     */
+    extractEntityReferences(entities) {
+        if (!entities) {
+            return {};
+        }
+        if (Array.isArray(entities)) {
+            // Format 1: Array of entity definitions - convert to self-references
+            const references = {};
+            for (const entity of entities) {
+                if (entity.name) {
+                    // Self-reference format: module.aggregate.entity
+                    references[entity.name] = `${this.parent.name}.${this.name}.${entity.name}`;
+                }
+            }
+            return references;
+        }
+        if (typeof entities === 'object') {
+            // Format 2: Object with string references - use as-is
+            return { ...entities };
+        }
+        return {};
+    }
+    //#endregion
+    //#region ----   Navigation Helpers   ----
+    /**
+     * Get entity reference by name
+     *
+     * @param entityName Name of the entity
+     * @returns Entity reference string or undefined if not found
+     */
+    getEntityReference(entityName) {
+        return this.entityReferences[entityName];
+    }
+    /**
+     * Get full path for an entity in this aggregate
+     *
+     * @param entityName Name of the entity
+     * @returns Full entity path
+     */
+    getEntityPath(entityName) {
+        return `${this.parent.name}.${this.name}.${entityName}`;
+    }
+    /**
+     * Get all available entity names
+     *
+     * @returns Array of entity names
+     */
+    getEntityNames() {
+        return Object.keys(this.entityReferences);
+    }
+    /**
+     * Check if entity exists in this aggregate
+     *
+     * @param entityName Name of the entity
+     * @returns True if entity exists
+     */
+    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   ----
+    /**
+     * Get parent module
+     *
+     * @returns Parent module model
+     */
+    getModule() {
+        return this.parent;
+    }
+    /**
+     * Get full aggregate path (module.aggregate)
+     *
+     * @returns Full path string
+     */
+    getPath() {
+        return `${this.parent.name}.${this.name}`;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get aggregate statistics
+     *
+     * @returns Statistics object
+     */
+    getStatistics() {
+        return {
+            entityCount: Object.keys(this.entityReferences).length,
+            relationCount: this.relations.length,
+            actionCount: this.actions.length,
+            validationCount: this.validations.length
+        };
+    }
+    /**
+     * Convert back to interface definition
+     *
+     * @returns Aggregate definition
+     */
+    toDefinition() {
+        return {
+            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
+        };
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validate the aggregate structure (synchronous validation only)
+     *
+     * @returns Array of validation errors
+     */
+    validate() {
+        const errors = [];
+        // Validate aggregate structure
+        if (!this.name)
+            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') {
+                errors.push(`Invalid entity reference for '${entityName}': must be a non-empty string`);
+            }
+        }
+        return errors;
+    }
+}
+//#endregion
+
+//#region ----   AXPModuleModel   ----
+/**
+ * Simple runtime model for module definitions with navigation helpers.
+ *
+ * This model is a pure data structure that provides:
+ * - Access to module properties and metadata
+ * - Navigation helpers for finding aggregates
+ * - Hierarchy navigation and path generation
+ *
+ * All loading and resolution logic has been moved to AXPDomainRegistry.
+ */
+class AXPModuleModel {
+    constructor(definition) {
+        this.aggregates = [];
+        this.name = definition.name;
+        this.title = definition.title;
+        // Initialize aggregates with parent reference (simplified constructor)
+        this.aggregates = (definition.aggregates || []).map(aggDef => new AXPAggregateModel(aggDef, this));
+    }
+    //#endregion
+    //#region ----   Navigation Helpers   ----
+    /**
+     * Find aggregate by name
+     *
+     * @param name Aggregate name
+     * @returns Aggregate model or undefined if not found
+     */
+    findAggregate(name) {
+        return this.aggregates.find(agg => agg.name === name);
+    }
+    /**
+     * Get all aggregates
+     *
+     * @returns Array of all aggregate models
+     */
+    getAllAggregates() {
+        return [...this.aggregates];
+    }
+    /**
+     * Check if aggregate exists in this module
+     *
+     * @param name Aggregate name
+     * @returns True if aggregate exists
+     */
+    hasAggregate(name) {
+        return this.aggregates.some(agg => agg.name === name);
+    }
+    /**
+     * Get all aggregate names
+     *
+     * @returns Array of aggregate names
+     */
+    getAggregateNames() {
+        return this.aggregates.map(agg => agg.name);
+    }
+    /**
+     * Find entity reference across all aggregates
+     *
+     * @param entityName Entity name to search for
+     * @returns Object with aggregate and entity reference, or undefined if not found
+     */
+    findEntityReference(entityName) {
+        for (const aggregate of this.aggregates) {
+            const entityReference = aggregate.getEntityReference(entityName);
+            if (entityReference) {
+                return { aggregate, entityReference };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get entity path for a specific entity in a specific aggregate
+     *
+     * @param aggregateName Aggregate name
+     * @param entityName Entity name
+     * @returns Full entity path
+     */
+    getEntityPath(aggregateName, entityName) {
+        return `${this.name}.${aggregateName}.${entityName}`;
+    }
+    /**
+     * Get aggregate path
+     *
+     * @param aggregateName Aggregate name
+     * @returns Full aggregate path
+     */
+    getAggregatePath(aggregateName) {
+        return `${this.name}.${aggregateName}`;
+    }
+    //#endregion
+    //#region ----   Query Methods   ----
+    /**
+     * Get all entity references across all aggregates
+     *
+     * @returns Map of entity name to full path
+     */
+    getAllEntityReferences() {
+        const allReferences = {};
+        for (const aggregate of this.aggregates) {
+            const aggregateReferences = aggregate.entityReferences;
+            for (const [entityName, entityRef] of Object.entries(aggregateReferences)) {
+                // Use full path as key to avoid conflicts
+                const fullKey = `${aggregate.name}.${entityName}`;
+                allReferences[fullKey] = entityRef;
+            }
+        }
+        return allReferences;
+    }
+    /**
+     * Get all relations across all aggregates
+     *
+     * @returns Array of all relation models
+     */
+    getAllRelations() {
+        const allRelations = [];
+        for (const aggregate of this.aggregates) {
+            for (const relation of aggregate.relations) {
+                allRelations.push({ aggregate, relation });
+            }
+        }
+        return allRelations;
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validate the module structure (synchronous validation only)
+     *
+     * @returns Array of validation errors
+     */
+    validate() {
+        const errors = [];
+        // Validate module structure
+        if (!this.name)
+            errors.push('Module name is required');
+        if (!this.title)
+            errors.push('Module title is required');
+        // Check for duplicate aggregate names
+        const aggregateNames = this.aggregates.map(agg => agg.name);
+        const duplicateNames = aggregateNames.filter((name, index) => aggregateNames.indexOf(name) !== index);
+        if (duplicateNames.length > 0) {
+            errors.push(`Duplicate aggregate names: ${duplicateNames.join(', ')}`);
+        }
+        // Validate aggregates
+        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),
+            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,
+            aggregates: this.aggregates.map(agg => agg.toDefinition())
+        };
+    }
+}
+//#endregion
+
+//#region ----   AXPEntityFieldModel   ----
+/**
+ * Runtime model for entity field definitions with parent references and helper methods
+ */
+class AXPEntityFieldModel {
+    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.features = definition.features;
+        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);
+    }
+    //#endregion
+    //#region ----   Feature Check Methods   ----
+    /**
+     * Check if field is nullable
+     */
+    isNullable() {
+        return this.features?.nullable ?? false;
+    }
+    /**
+     * Check if field is readonly
+     */
+    isReadonly() {
+        return this.features?.readOnly ?? false;
+    }
+    /**
+     * Check if field is required (has required validation)
+     */
+    isRequired() {
+        return this.validations?.some(validation => validation.rule === 'required') ?? false;
+    }
+    /**
+     * Check if field is searchable
+     */
+    isSearchable() {
+        return this.schema.features?.searchable?.enabled ?? false;
+    }
+    /**
+     * Check if field supports full text search
+     */
+    isFullTextSearchable() {
+        return this.schema.features?.searchable?.fullText ?? false;
+    }
+    /**
+     * Check if field is filterable
+     */
+    isFilterable() {
+        return this.schema.features?.filterable?.enabled ?? false;
+    }
+    /**
+     * Check if field has inline filtering
+     */
+    hasInlineFiltering() {
+        return this.schema.features?.filterable?.inline ?? false;
+    }
+    /**
+     * Check if field is sortable
+     */
+    isSortable() {
+        return this.schema.features?.sortable?.enabled ?? false;
+    }
+    /**
+     * Check if field is auditable
+     */
+    isAuditable() {
+        return this.schema.features?.auditable?.enabled ?? false;
+    }
+    //#endregion
+    //#region ----   Schema Methods   ----
+    /**
+     * Get the schema name
+     */
+    getSchemaName() {
+        return this.schemaName;
+    }
+    /**
+     * Get schema info from registry
+     */
+    getSchemaInfo() {
+        return this.schemaService.getSchemaInfo(this.schemaName);
+    }
+    /**
+     * Re-resolve schema from registry (useful after schema updates)
+     */
+    refreshSchema() {
+        const newSchema = this.schemaService.resolveSync(this.schemaName);
+        this.schema = newSchema;
+        this.schema.parent = this;
+    }
+    //#endregion
+    //#region ----   Navigation Methods   ----
+    /**
+     * Get parent entity
+     */
+    getEntity() {
+        return this.parent;
+    }
+    /**
+     * Get parent aggregate
+     */
+    getAggregate() {
+        return this.parent?.parent;
+    }
+    /**
+     * Get parent module
+     */
+    getModule() {
+        return this.parent?.parent?.parent;
+    }
+    /**
+     * Get full path (module.aggregate.entity.field)
+     */
+    getPath() {
+        return `${this.parent.parent.parent.name}.${this.parent.parent.name}.${this.parent.name}.${this.name}`;
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validate the field structure
+     */
+    async validate() {
+        const errors = [];
+        // Validate field structure
+        if (!this.name)
+            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}`));
+            }
+        }
+        return errors;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get field statistics
+     */
+    getStatistics() {
+        return {
+            hasValidations: !!this.validations && this.validations.length > 0,
+            hasActions: !!this.actions && this.actions.length > 0,
+            hasFeatures: !!this.features,
+            hasDefaultValue: this.defaultValue !== undefined,
+            validationCount: this.validations?.length ?? 0,
+            actionCount: this.actions?.length ?? 0
+        };
+    }
+    /**
+     * Get field capabilities
+     */
+    getCapabilities() {
+        return {
+            searchable: this.isSearchable(),
+            filterable: this.isFilterable(),
+            sortable: this.isSortable(),
+            auditable: this.isAuditable(),
+            nullable: this.isNullable(),
+            readonly: this.isReadonly(),
+            required: this.isRequired()
+        };
+    }
+    /**
+     * Convert back to interface definition
+     */
+    toDefinition() {
+        return {
+            name: this.name,
+            title: this.title,
+            description: this.description,
+            validations: this.validations,
+            actions: this.actions,
+            features: this.features,
+            defaultValue: this.defaultValue,
+            schema: this.schemaName
+        };
+    }
+}
+
+//#region ----   AXPEntityModel   ----
+/**
+ * Runtime model for entity definitions with parent references and helper methods
+ */
+class AXPEntityModel {
+    constructor(definition, parent, schemaService) {
+        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));
+    }
+    //#endregion
+    //#region ----   Query Methods   ----
+    /**
+     * Find field by name
+     */
+    findField(name) {
+        return this.fields.find(field => field.name === name);
+    }
+    /**
+     * Get all fields
+     */
+    getAllFields() {
+        return [...this.fields];
+    }
+    /**
+     * Get fields by data type
+     */
+    getFieldsByType(dataType) {
+        return this.fields.filter(field => field.schema.dataType === dataType);
+    }
+    /**
+     * Get required fields
+     */
+    getRequiredFields() {
+        return this.fields.filter(field => field.isRequired());
+    }
+    /**
+     * Get readonly fields
+     */
+    getReadonlyFields() {
+        return this.fields.filter(field => field.isReadonly());
+    }
+    /**
+     * Get searchable fields
+     */
+    getSearchableFields() {
+        return this.fields.filter(field => field.isSearchable());
+    }
+    /**
+     * Get filterable fields
+     */
+    getFilterableFields() {
+        return this.fields.filter(field => field.isFilterable());
+    }
+    /**
+     * Get sortable fields
+     */
+    getSortableFields() {
+        return this.fields.filter(field => field.isSortable());
+    }
+    //#endregion
+    //#region ----   Type Checking Methods   ----
+    /**
+     * Check if this entity is an aggregate root
+     */
+    isAggregateRoot() {
+        return this.type === AXPEntityType.AggregateRoot;
+    }
+    /**
+     * Check if this entity is a regular entity
+     */
+    isEntity() {
+        return this.type === AXPEntityType.Entity;
+    }
+    /**
+     * Check if this entity is a value object
+     */
+    isValueObject() {
+        return this.type === AXPEntityType.ValueObject;
+    }
+    //#endregion
+    //#region ----   Navigation Methods   ----
+    /**
+     * Get parent aggregate
+     */
+    getAggregate() {
+        return this.parent;
+    }
+    /**
+     * Get parent module
+     */
+    getModule() {
+        return this.parent?.parent;
+    }
+    /**
+     * Get full path (module.aggregate.entity)
+     */
+    getPath() {
+        return `${this.parent.parent.name}.${this.parent.name}.${this.name}`;
+    }
+    //#endregion
+    //#region ----   Validation Methods   ----
+    /**
+     * Validate the entity structure
+     */
+    async validate() {
+        const errors = [];
+        // Validate entity structure
+        if (!this.name)
+            errors.push('Entity name is required');
+        if (!this.title)
+            errors.push('Entity title is required');
+        // Validate fields
+        for (const field of this.fields) {
+            const fieldErrors = await field.validate();
+            if (fieldErrors.length > 0) {
+                errors.push(...fieldErrors.map(err => `${field.name}: ${err}`));
+            }
+        }
+        return errors;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get entity statistics
+     */
+    getStatistics() {
+        return {
+            fieldCount: this.fields.length,
+            requiredFieldCount: this.getRequiredFields().length,
+            readonlyFieldCount: this.getReadonlyFields().length,
+            searchableFieldCount: this.getSearchableFields().length,
+            filterableFieldCount: this.getFilterableFields().length,
+            sortableFieldCount: this.getSortableFields().length
+        };
+    }
+    /**
+     * Convert back to interface definition
+     */
+    toDefinition() {
+        return {
+            name: this.name,
+            title: this.title,
+            fields: this.fields.map(field => field.toDefinition()),
+            type: this.type
+        };
+    }
+}
+
+//#region ----   AXPSchemaModel   ----
+/**
+ * Runtime model for schema definitions with helper methods
+ */
+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 ----   Data Type Methods   ----
+    /**
+     * Check if schema is for string data
+     */
+    isString() {
+        return this.dataType === 'string';
+    }
+    /**
+     * Check if schema is for number data
+     */
+    isNumber() {
+        return this.dataType === 'number';
+    }
+    /**
+     * Check if schema is for boolean data
+     */
+    isBoolean() {
+        return this.dataType === 'boolean';
+    }
+    /**
+     * Check if schema is for date data
+     */
+    isDate() {
+        return this.dataType === 'date';
+    }
+    /**
+     * Check if schema is for object data
+     */
+    isObject() {
+        return this.dataType === 'object';
+    }
+    /**
+     * Check if schema is for array data
+     */
+    isArray() {
+        return this.dataType === 'array';
+    }
+    /**
+     * Check if schema is for blob data
+     */
+    isBlob() {
+        return this.dataType === 'blob';
+    }
+    //#endregion
+    //#region ----   Interface Methods   ----
+    /**
+     * Get widget type
+     */
+    getWidgetType() {
+        return this.interface.widget;
+    }
+    /**
+     * Get widget options
+     */
+    getWidgetOptions() {
+        return this.interface.options;
+    }
+    /**
+     * Check if interface is disabled
+     */
+    isDisabled() {
+        return this.interface.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 schema structure
+     */
+    async 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');
+        }
+        return errors;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Get schema 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 schema summary
+     */
+    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
+     */
+    toDefinition() {
+        return {
+            name: this.name,
+            dataType: this.dataType,
+            interface: this.interface,
+            validations: this.validations,
+            features: this.features,
+            metadata: this.metadata
+        };
+    }
+}
+
+//#region ----   AXPModuleHelper   ----
+/**
+ * Helper utility class for working with module models
+ *
+ * @deprecated This helper class is deprecated and will be updated to work with the new domain registry system.
+ * Use AXPDomainService for domain operations instead.
+ *
+ * TODO: Update this helper to work with the new simplified models and domain registry system.
+ */
+class AXPModuleHelper {
+    //#endregion
+    //#region ----   Deprecated Methods - To Be Updated   ----
+    /**
+     * @deprecated Use AXPDomainService.findEntitiesByName() instead
+     */
+    static findEntitiesByName(module, name) {
+        console.warn('AXPModuleHelper.findEntitiesByName is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with entity field queries instead
+     */
+    static findFieldsByName(module, fieldName) {
+        console.warn('AXPModuleHelper.findFieldsByName is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with entity type queries instead
+     */
+    static findEntitiesByType(module, type) {
+        console.warn('AXPModuleHelper.findEntitiesByType is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with field validation queries instead
+     */
+    static findFieldsWithValidation(module, validationRule) {
+        console.warn('AXPModuleHelper.findFieldsWithValidation is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with field queries instead
+     */
+    static findFieldsByDataType(module, dataType) {
+        console.warn('AXPModuleHelper.findFieldsByDataType is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with required field queries instead
+     */
+    static findRequiredFields(module) {
+        console.warn('AXPModuleHelper.findRequiredFields is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with nullable field queries instead
+     */
+    static findNullableFields(module) {
+        console.warn('AXPModuleHelper.findNullableFields is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with default value queries instead
+     */
+    static findFieldsWithDefaultValues(module) {
+        console.warn('AXPModuleHelper.findFieldsWithDefaultValues is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with field schema queries instead
+     */
+    static findFieldsBySchema(module, schemaName) {
+        console.warn('AXPModuleHelper.findFieldsBySchema is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use module.validate() method instead
+     */
+    static validateModule(module) {
+        return module.validate();
+    }
+    /**
+     * @deprecated Use aggregate relation queries instead
+     */
+    static findRelationsByType(module, relationType) {
+        console.warn('AXPModuleHelper.findRelationsByType is deprecated. Use relation queries instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with entity dependency queries instead
+     */
+    static findEntityDependencies(module, entityName) {
+        console.warn('AXPModuleHelper.findEntityDependencies is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use module.getStatistics() method instead
+     */
+    static getModuleStatistics(module) {
+        return module.getStatistics();
+    }
+    /**
+     * @deprecated Use AXPDomainService with entity queries instead
+     */
+    static getAllEntities(module) {
+        console.warn('AXPModuleHelper.getAllEntities is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+    /**
+     * @deprecated Use AXPDomainService with field queries instead
+     */
+    static getAllFields(module) {
+        console.warn('AXPModuleHelper.getAllFields is deprecated. Use AXPDomainService instead.');
+        return [];
+    }
+}
+
+//#region ----   Schema Middleware Context   ----
+/**
+ * Context class for schema middleware operations providing a fluent API for schema manipulation.
+ *
+ * This class serves as the interface between middleware functions and schema definitions,
+ * offering methods to modify various aspects of a schema including:
+ * - Widget configuration and options
+ * - Validation rules
+ * - Feature flags (searchable, filterable, sortable)
+ * - Metadata and custom properties
+ * - UI behavior (visibility, readonly state)
+ *
+ * All methods return `this` to enable fluent method chaining.
+ *
+ * @example
+ * ```typescript
+ * // Example middleware using the context
+ * (context) => {
+ *   context
+ *     .addValidation({ rule: 'required' })
+ *     .searchable(true)
+ *     .withDefaultValue('default text')
+ *     .readonly(false);
+ * }
+ * ```
+ */
+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 schema() {
+        return this._schema;
+    }
+    /**
+     * Get the schema name for conditional logic
+     */
+    get name() {
+        return this._schema.name;
+    }
+    //#endregion
+    //#region ----   Default Value Management   ----
+    /**
+     * Set a default value for the widget
+     * @param defaultValue The default value to set
+     */
+    withDefaultValue(defaultValue) {
+        if (!this._schema.interface.options) {
+            this._schema.interface.options = {};
+        }
+        this._schema.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'];
+        }
+        return this;
+    }
+    //#endregion
+    //#region ----   Validation Management   ----
+    /**
+     * Add multiple validation rules to the schema
+     * @param rules Array of validation rules to add
+     */
+    withValidation(rules) {
+        if (!this._schema.validations) {
+            this._schema.validations = [];
+        }
+        this._schema.validations.push(...rules);
+        return this;
+    }
+    /**
+     * Add a single validation rule to the schema
+     * @param rule The validation rule to add
+     */
+    addValidation(rule) {
+        if (!this._schema.validations) {
+            this._schema.validations = [];
+        }
+        this._schema.validations.push(rule);
+        return this;
+    }
+    /**
+     * Add a single validation rule (alias for addValidation for backward compatibility)
+     * @param rule The validation rule to add
+     */
+    withValidationRule(rule) {
+        return this.addValidation(rule);
+    }
+    /**
+     * Remove all validation rules from the schema
+     */
+    clearValidations() {
+        this._schema.validations = [];
+        return this;
+    }
+    /**
+     * Remove a specific validation rule by its rule name
+     * @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);
+        }
+        return this;
+    }
+    //#endregion
+    //#region ----   Widget Configuration   ----
+    /**
+     * Set or merge widget options
+     * @param options Object containing widget-specific options to merge
+     */
+    withWidgetOptions(options) {
+        this._schema.interface.options = {
+            ...this._schema.interface.options,
+            ...options
+        };
+        return this;
+    }
+    /**
+     * Remove a specific widget option by key
+     * @param optionKey The key of the option to remove
+     */
+    removeWidgetOption(optionKey) {
+        if (this._schema.interface.options) {
+            delete this._schema.interface.options[optionKey];
+        }
+        return this;
+    }
+    /**
+     * Change the widget type for this schema
+     * @param widgetType The new widget type identifier
+     */
+    withWidgetType(widgetType) {
+        this._schema.interface.widget = widgetType;
+        return this;
+    }
+    //#endregion
+    //#region ----   Feature Configuration   ----
+    /**
+     * Configure general features using an object
+     * @param features Object containing feature configurations to merge
+     */
+    withFeatures(features) {
+        this._schema.features = {
+            ...this._schema.features,
+            ...features
+        };
+        return this;
+    }
+    /**
+     * Configure searchable feature with fine-grained control
+     * @param enabled Whether searching is enabled
+     * @param fullText Whether full-text search is enabled
+     */
+    searchable(enabled = true, fullText = false) {
+        if (!this._schema.features) {
+            this._schema.features = {};
+        }
+        this._schema.features.searchable = { enabled, fullText };
+        return this;
+    }
+    /**
+     * Configure filterable feature with inline filter support
+     * @param enabled Whether filtering is enabled
+     * @param inline Whether inline filtering is supported
+     */
+    filterable(enabled = true, inline = false) {
+        if (!this._schema.features) {
+            this._schema.features = {};
+        }
+        this._schema.features.filterable = { enabled, inline };
+        return this;
+    }
+    /**
+     * Configure sortable feature
+     * @param enabled Whether sorting is enabled
+     */
+    sortable(enabled = true) {
+        if (!this._schema.features) {
+            this._schema.features = {};
+        }
+        this._schema.features.sortable = { enabled };
+        return this;
+    }
+    //#endregion
+    //#region ----   Metadata Management   ----
+    /**
+     * Add or merge metadata to the schema
+     * @param metadata Object containing metadata to merge
+     */
+    withMetadata(metadata) {
+        this._schema.metadata = {
+            ...this._schema.metadata,
+            ...metadata
+        };
+        return this;
+    }
+    /**
+     * Remove a specific metadata property by key
+     * @param key The metadata key to remove
+     */
+    removeMetadata(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._schema.interface.disabled = isDisabled;
+        return this;
+    }
+    /**
+     * Set the visibility of the widget
+     * @param visible Whether the widget should be visible
+     */
+    withVisibility(visible) {
+        if (!this._schema.interface.options) {
+            this._schema.interface.options = {};
+        }
+        this._schema.interface.options['visible'] = visible;
+        return this;
+    }
+    /**
+     * Set the readonly state of the widget
+     * @param isReadonly Whether the widget should be readonly
+     */
+    readonly(isReadonly = true) {
+        if (!this._schema.interface.options) {
+            this._schema.interface.options = {};
+        }
+        this._schema.interface.options['readonly'] = isReadonly;
+        return this;
+    }
+}
+//#endregion
+//#region ----   Builder-Based Middleware Types   ----
+
+//#endregion
+//#region ----   Schema Registry Service   ----
+/**
+ * Central registry for managing schema definitions, middleware, and dynamic loading.
+ *
+ * Provides:
+ * - Schema registration and retrieval
+ * - Middleware processing pipeline
+ * - On-demand schema loading
+ * - Caching and performance optimization
+ */
+class AXPSchemaRegistry {
+    constructor() {
+        this._schemas = new Map();
+        this._globalMiddleware = [];
+        this._modelCache = new Map();
+        this._loaders = null;
+    }
+    //#region ----   Registration Methods   ----
+    /**
+     * Register a schema definition with optional metadata and middleware
+     */
+    register(definition, options = {}) {
+        if (!definition.name || definition.name.trim() === '') {
+            throw new Error('Schema name is required and cannot be empty');
+        }
+        const registered = {
+            name: definition.name,
+            definition,
+            options,
+            registeredAt: new Date()
+        };
+        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(schemas) {
+        for (const schema of schemas) {
+            this.register(schema.definition, schema.options || {});
+        }
+    }
+    /**
+     * Remove a schema from the registry
+     */
+    unregister(name) {
+        const removed = this._schemas.delete(name);
+        if (removed) {
+            this.invalidateCache(name);
+        }
+        return removed;
+    }
+    /**
+     * Check if a schema is currently registered
+     */
+    isRegistered(name) {
+        return this._schemas.has(name);
+    }
+    //#endregion
+    //#region ----   Resolution Methods   ----
+    /**
+     * Resolve a schema by name with full middleware processing and caching.
+     * Supports on-demand loading if schema is not registered.
+     */
+    async resolve(name) {
+        // Check cache first for performance
+        if (this._modelCache.has(name)) {
+            return this._modelCache.get(name);
+        }
+        // Try to get from registered schemas first
+        let registered = this._schemas.get(name);
+        // If not found, attempt on-demand loading
+        if (!registered) {
+            const definition = await this.loadFromLoaders(name);
+            if (definition) {
+                registered = {
+                    name,
+                    definition,
+                    options: {},
+                    registeredAt: new Date()
+                };
+                this._schemas.set(name, registered);
+            }
+            else {
+                throw new Error(`Schema '${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);
+        // Apply global middleware first
+        for (const middleware of this._globalMiddleware) {
+            await middleware(context);
+        }
+        // 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 AXPSchemaModel(context.schema);
+        this._modelCache.set(name, model);
+        return model;
+    }
+    /**
+     * Synchronous resolution without middleware processing.
+     * Use only when middleware is not needed for performance.
+     */
+    resolveSync(name) {
+        const registered = this._schemas.get(name);
+        if (!registered) {
+            throw new Error(`Schema '${name}' is not registered`);
+        }
+        return new AXPSchemaModel(this.cloneDefinition(registered.definition));
+    }
+    //#endregion
+    //#region ----   Middleware Management   ----
+    /**
+     * Add global middleware that applies to all schema resolutions
+     */
+    addGlobalMiddleware(middleware) {
+        if (typeof middleware !== 'function') {
+            throw new Error('Middleware must be a function');
+        }
+        this._globalMiddleware.push(middleware);
+    }
+    /**
+     * Remove specific global middleware
+     */
+    removeGlobalMiddleware(middleware) {
+        const index = this._globalMiddleware.indexOf(middleware);
+        if (index > -1) {
+            this._globalMiddleware.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clear all global middleware
+     */
+    clearGlobalMiddleware() {
+        this._globalMiddleware.length = 0;
+    }
+    //#endregion
+    //#region ----   Loader Management   ----
+    /**
+     * Add a schema loader for on-demand loading
+     */
+    addLoader(loader) {
+        if (this._loaders === null) {
+            this._loaders = [];
+        }
+        this._loaders.push(new loader());
+    }
+    //#endregion
+    //#region ----   Query Methods   ----
+    /**
+     * Get all registered schema names
+     */
+    getRegisteredNames() {
+        return Array.from(this._schemas.keys());
+    }
+    /**
+     * Get detailed registration information for a schema
+     */
+    getSchemaInfo(name) {
+        return this._schemas.get(name);
+    }
+    /**
+     * Get all registered schemas with their metadata
+     */
+    getAllSchemas() {
+        return Array.from(this._schemas.values());
+    }
+    /**
+     * Find schemas by tag for categorization
+     */
+    findByTag(tag) {
+        return Array.from(this._schemas.values()).filter(schema => schema.options.tags?.includes(tag));
+    }
+    /**
+     * Find schemas by widget type for widget-specific operations
+     */
+    findByWidget(widgetType) {
+        return Array.from(this._schemas.values()).filter(schema => schema.definition.interface.widget === 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;
+                }
+            }
+        }
+        return {
+            schemaCount: this._schemas.size,
+            globalMiddlewareCount: this._globalMiddleware.length,
+            schemasByWidget,
+            schemasByTag
+        };
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /**
+     * Clear all cached models (useful when schemas need to be reloaded)
+     */
+    clearCache() {
+        this._modelCache.clear();
+    }
+    /**
+     * Invalidate cache for a specific schema
+     */
+    invalidateCache(name) {
+        this._modelCache.delete(name);
+    }
+    /**
+     * Clear all registered schemas, middleware, and cached models
+     */
+    clear() {
+        this._schemas.clear();
+        this._globalMiddleware.length = 0;
+        this._modelCache.clear();
+        this._loaders = null;
+    }
+    //#endregion
+    //#region ----   Private Helper Methods   ----
+    /**
+     * Attempt to load schema from registered loaders
+     */
+    async loadFromLoaders(name) {
+        const loaders = this.getLoaders();
+        for (const loader of loaders) {
+            if (loader.canLoad(name)) {
+                try {
+                    const definition = await loader.load(name);
+                    if (definition) {
+                        console.log(`Schema '${name}' loaded from ${loader.constructor.name}`);
+                        return definition;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Loader ${loader.constructor.name} failed to load '${name}':`, error);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Get loaders sorted by priority (lazy initialization)
+     */
+    getLoaders() {
+        if (this._loaders === null) {
+            try {
+                this._loaders = [];
+                // Sort by priority (higher priority first)
+                this._loaders.sort((a, b) => {
+                    const priorityA = a.priority ?? 0;
+                    const priorityB = b.priority ?? 0;
+                    return priorityB - priorityA;
+                });
+            }
+            catch (error) {
+                console.warn('Failed to initialize schema loaders:', error);
+                this._loaders = [];
+            }
+        }
+        return this._loaders;
+    }
+    /**
+     * Create a deep clone of a schema definition to prevent mutations
+     */
+    cloneDefinition(definition) {
+        return JSON.parse(JSON.stringify(definition));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Schema Service   ----
+/**
+ * High-level facade service for schema operations.
+ *
+ * Provides a simplified interface to the schema registry with additional
+ * business logic and convenience methods for common operations.
+ */
+class AXPSchemaService {
+    constructor() {
+        this.registry = inject(AXPSchemaRegistry);
+    }
+    //#region ----   Core Schema Management   ----
+    /**
+     * Register a schema with optional configuration
+     */
+    register(definition, options) {
+        this.registry.register(definition, options);
+    }
+    /**
+     * Register multiple schemas at once
+     */
+    registerBatch(schemas) {
+        this.registry.registerBatch(schemas);
+    }
+    /**
+     * Remove a schema from the registry
+     */
+    unregister(name) {
+        return this.registry.unregister(name);
+    }
+    /**
+     * Check if a schema is registered
+     */
+    isRegistered(name) {
+        return this.registry.isRegistered(name);
+    }
+    /**
+     * Get all registered schema names
+     */
+    getRegisteredNames() {
+        return this.registry.getRegisteredNames();
+    }
+    /**
+     * Clear all schemas and reset the registry
+     */
+    clear() {
+        this.registry.clear();
+    }
+    //#endregion
+    //#region ----   Schema Resolution   ----
+    /**
+     * Resolve a schema with full middleware processing
+     */
+    async resolve(name) {
+        return this.registry.resolve(name);
+    }
+    /**
+     * Resolve schema synchronously without middleware (for performance)
+     */
+    resolveSync(name) {
+        return this.registry.resolveSync(name);
+    }
+    /**
+     * Resolve multiple schemas 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)
+        })));
+        return resolvedFields;
+    }
+    //#endregion
+    //#region ----   Middleware Management   ----
+    /**
+     * Add global middleware that applies to all schema resolutions
+     */
+    addGlobalMiddleware(middleware) {
+        this.registry.addGlobalMiddleware(middleware);
+    }
+    /**
+     * Remove specific global middleware
+     */
+    removeGlobalMiddleware(middleware) {
+        return this.registry.removeGlobalMiddleware(middleware);
+    }
+    /**
+     * Clear all global middleware
+     */
+    clearGlobalMiddleware() {
+        this.registry.clearGlobalMiddleware();
+    }
+    //#endregion
+    //#region ----   Query and Discovery   ----
+    /**
+     * Get detailed information about a registered schema
+     */
+    getSchemaInfo(name) {
+        return this.registry.getSchemaInfo(name);
+    }
+    /**
+     * Get all registered schemas with their metadata
+     */
+    getAllSchemas() {
+        return this.registry.getAllSchemas();
+    }
+    /**
+     * Find schemas by tag for categorization and grouping
+     */
+    findByTag(tag) {
+        return this.registry.findByTag(tag);
+    }
+    /**
+     * Find schemas by widget type for widget-specific operations
+     */
+    findByWidget(widgetType) {
+        return this.registry.findByWidget(widgetType);
+    }
+    /**
+     * Get comprehensive registry statistics and analytics
+     */
+    getStatistics() {
+        const stats = this.registry.getStatistics();
+        // Enhance with top-used analytics
+        const mostUsedWidgets = Object.entries(stats.schemasByWidget)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 5)
+            .map(([widget]) => widget);
+        const mostUsedTags = Object.entries(stats.schemasByTag)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 5)
+            .map(([tag]) => tag);
+        return {
+            ...stats,
+            mostUsedWidgets,
+            mostUsedTags
+        };
+    }
+    //#endregion
+    //#region ----   Validation and Analysis   ----
+    /**
+     * Validate that all referenced schemas exist in the registry
+     */
+    validateSchemaReferences(schemaNames) {
+        const missingSchemas = [];
+        for (const schemaName of schemaNames) {
+            if (!this.isRegistered(schemaName)) {
+                missingSchemas.push(schemaName);
+            }
+        }
+        return {
+            valid: missingSchemas.length === 0,
+            missingSchemas
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPSchemaService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#endregion
+
+//#endregion
+//#region ----   Provider Functions   ----
+/**
+ * Provide schema loaders for on-demand schema loading.
+ *
+ * Schema loaders enable the registry to load schemas that are not registered
+ * at build time. This is useful for:
+ * - Loading schemas from external APIs
+ * - Dynamic schema generation
+ * - Lazy loading of large schema sets
+ * - Development-time schema hot-reloading
+ *
+ * @param loaders Array of loader classes or loader configurations
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * // Simple loader registration
+ * provideSchemaLoaders([
+ *   HttpSchemaLoader,
+ *   FileSystemSchemaLoader
+ * ])
+ *
+ * // With priority configuration
+ * provideSchemaLoaders([
+ *   { loader: HttpSchemaLoader, priority: 10 },
+ *   { loader: FileSystemSchemaLoader, priority: 5 }
+ * ])
+ * ```
+ */
+function provideSchemaLoaders(loaders) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_SCHEMA_LOADER_SETUP,
+            useFactory: async () => {
+                const registry = inject(AXPSchemaRegistry);
+                // Register each loader with the registry
+                for (const loader of loaders) {
+                    const loaderClass = typeof loader === 'function' ? loader : loader.loader;
+                    registry.addLoader(loaderClass);
+                }
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+//#endregion
+
+//#endregion
+//#region ----   Provider Functions   ----
+/**
+ * Provide schema setups for registration during application bootstrap.
+ *
+ * This is the primary way to register schemas that are known at build time.
+ * Schemas registered this way are immediately available in the registry.
+ *
+ * @param schemas Array of schema entries to register
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideSchemaSetups([
+ *   {
+ *     definition: emailSchema,
+ *     options: {
+ *       tags: ['user', 'contact'],
+ *       description: 'Email field schema'
+ *     }
+ *   },
+ *   {
+ *     definition: phoneSchema,
+ *     options: { tags: ['contact'] }
+ *   }
+ * ])
+ * ```
+ */
+function provideSchemaSetups(schemas) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_SCHEMA_SETUP,
+            useFactory: () => {
+                const registry = inject(AXPSchemaRegistry);
+                // Register all schemas with their options
+                for (const schema of schemas) {
+                    registry.register(schema.definition, schema.options);
+                }
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+/**
+ * Convenience function to provide a single schema setup.
+ *
+ * Useful when you need to register just one schema or want to keep
+ * schema registrations separate for organizational purposes.
+ *
+ * @param definition The schema definition to register
+ * @param options Optional registration options and metadata
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideSchema(emailSchema, {
+ *   tags: ['user', 'contact'],
+ *   description: 'User email field'
+ * })
+ * ```
+ */
+function provideSchema(definition, options) {
+    return provideSchemaSetups([{ definition, options }]);
+}
+/**
+ * Provide schema setups from a factory function for dynamic registration.
+ *
+ * Useful when schemas need to be generated at runtime, loaded from external
+ * sources, or depend on configuration that's not available at build time.
+ *
+ * @param schemaFactory Factory function that returns schema entries
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideSchemasFromFactory(async () => {
+ *   const config = await loadConfiguration();
+ *   return config.schemas.map(schema => ({
+ *     definition: schema,
+ *     options: { tags: ['dynamic'] }
+ *   }));
+ * })
+ * ```
+ */
+function provideSchemasFromFactory(schemaFactory) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_SCHEMA_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);
+                }
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+//#endregion
+
+//#endregion
+//#region ----   Provider Functions   ----
+/**
+ * Provide schema middleware for registration in the application.
+ *
+ * Supports both global middleware (applies to all schemas) and targeted middleware
+ * (applies only to schemas matching specific patterns).
+ *
+ * @param middleware Array of middleware entries to register
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * // Global middleware
+ * provideSchemaMiddleware([
+ *   (context) => {
+ *     if (context.schema.dataType === 'string') {
+ *       context.searchable(true);
+ *     }
+ *   }
+ * ])
+ *
+ * // Targeted middleware
+ * provideSchemaMiddleware([
+ *   {
+ *     target: /^user_/,
+ *     middleware: (context) => context.withMetadata({ category: 'user' })
+ *   }
+ * ])
+ * ```
+ */
+function provideSchemaMiddleware(middleware) {
+    const global = [];
+    const targeted = [];
+    // Separate global and targeted middleware for different processing
+    for (const entry of middleware) {
+        if (typeof entry === 'function') {
+            global.push(entry);
+        }
+        else {
+            targeted.push(entry);
+        }
+    }
+    return makeEnvironmentProviders([
+        // Setup global middleware that applies to all schemas
+        ...(global.length > 0 ? [{
+                provide: AXP_SCHEMA_MIDDLEWARE_SETUP,
+                useFactory: () => {
+                    const registry = inject(AXPSchemaRegistry);
+                    for (const mw of global) {
+                        registry.addGlobalMiddleware(mw);
+                    }
+                    return true;
+                },
+                multi: true
+            }] : []),
+        // Register targeted middleware entries for future extension support
+        ...targeted.map(entry => ({
+            provide: AXP_SCHEMA_EXTENSION,
+            useValue: entry,
+            multi: true
+        }))
+    ]);
+}
+//#endregion
+
+//#region ----   Core Schema Registry   ----
+// Core registry and service classes
+//#endregion
+
+//#region ----   Domain Middleware Context   ----
+/**
+ * Context class for domain middleware operations providing a fluent API for domain definition manipulation.
+ *
+ * This class serves as the interface between middleware functions and domain definitions,
+ * offering methods to modify various aspects of a domain definition including:
+ * - Metadata and custom properties
+ * - Validation rules
+ * - Feature flags and configuration
+ * - Transformations and augmentations
+ *
+ * All methods return `this` to enable fluent method chaining.
+ */
+class AXPDomainMiddlewareContext {
+    constructor(definition, type) {
+        // Deep clone to avoid mutating the original definition
+        this._definition = JSON.parse(JSON.stringify(definition));
+        this._type = type;
+    }
+    /**
+     * Get the current definition (read-only access)
+     */
+    get definition() {
+        return this._definition;
+    }
+    /**
+     * Get the type of domain object being processed
+     */
+    get type() {
+        return this._type;
+    }
+    /**
+     * Set metadata for the domain definition
+     */
+    setMetadata(key, value) {
+        const def = this._definition;
+        if (!def.metadata) {
+            def.metadata = {};
+        }
+        def.metadata[key] = value;
+        return this;
+    }
+    /**
+     * Get metadata value
+     */
+    getMetadata(key) {
+        const def = this._definition;
+        return def.metadata?.[key];
+    }
+    /**
+     * Add validation rule to the definition (for entities and aggregates)
+     */
+    addValidation(rule) {
+        if ('validations' in this._definition) {
+            this._definition.validations = this._definition.validations || [];
+            this._definition.validations.push(rule);
+        }
+        return this;
+    }
+    /**
+     * Transform fields (for entities)
+     */
+    transformFields(transformer) {
+        if ('fields' in this._definition && this._definition.fields) {
+            this._definition.fields = this._definition.fields.map(transformer);
+        }
+        return this;
+    }
+    /**
+     * Add field to entity definition
+     */
+    addField(field) {
+        if ('fields' in this._definition) {
+            this._definition.fields = this._definition.fields || [];
+            this._definition.fields.push(field);
+        }
+        return this;
+    }
+    /**
+     * Set title with transformation
+     */
+    setTitle(title) {
+        this._definition.title = title;
+        return this;
+    }
+    /**
+     * Apply conditional logic
+     */
+    when(condition, callback) {
+        if (condition) {
+            callback(this);
+        }
+        return this;
+    }
+    /**
+     * Replace the entire definition
+     */
+    replaceDefinition(newDefinition) {
+        this._definition = JSON.parse(JSON.stringify(newDefinition));
+        return this;
+    }
+}
+//#endregion
+
+//#region ----   Domain Registry Service   ----
+/**
+ * Central registry for managing domain definitions, middleware, and dynamic loading.
+ *
+ * Provides:
+ * - Path-based domain resolution (module.aggregate.entity)
+ * - Definition-level caching with fresh model creation
+ * - Type-specific middleware processing
+ * - On-demand domain loading with first-wins strategy
+ * - Model creation and dependency injection
+ */
+class AXPDomainRegistry {
+    constructor() {
+        // Cache definitions (before middleware), not models
+        this._definitionCache = new Map();
+        // Type-specific middleware collections
+        this._moduleMiddleware = [];
+        this._aggregateMiddleware = [];
+        this._entityMiddleware = [];
+        // Registered loaders for on-demand loading
+        this._loaders = [];
+        // Injected dependencies
+        this.schemaService = inject(AXPSchemaService);
+    }
+    //#region ----   Main Resolution Method   ----
+    /**
+     * Resolve a domain object by path with full middleware processing.
+     * Supports definition-level caching with fresh model creation.
+     *
+     * @param path Domain path (e.g., "user-management.user-aggregate.user")
+     * @returns Promise that resolves to the domain model
+     */
+    async resolve(path) {
+        const pathInfo = this.parsePath(path);
+        // Check definition cache first
+        let definition = this._definitionCache.get(path);
+        if (!definition) {
+            // Load from first available loader
+            definition = await this.loadFromLoaders(path, pathInfo.type);
+            if (!definition) {
+                throw new Error(`Cannot resolve domain path: ${path}`);
+            }
+            // Cache the raw definition
+            this._definitionCache.set(path, definition);
+        }
+        // Apply type-specific middleware (creates new processed definition)
+        const processedDefinition = await this.applyTypeMiddleware(definition, pathInfo.type, path);
+        // Create and return fresh model instance (not cached)
+        return this.createModel(processedDefinition, pathInfo);
+    }
+    //#endregion
+    //#region ----   Path Parsing   ----
+    /**
+     * Parse domain path string into structured information
+     *
+     * @param path Domain path to parse
+     * @returns Parsed path information
+     */
+    parsePath(path) {
+        const parts = path.split('.');
+        if (parts.length === 1) {
+            return {
+                module: parts[0],
+                type: 'module',
+                fullPath: path
+            };
+        }
+        else if (parts.length === 2) {
+            return {
+                module: parts[0],
+                aggregate: parts[1],
+                type: 'aggregate',
+                fullPath: path
+            };
+        }
+        else if (parts.length === 3) {
+            return {
+                module: parts[0],
+                aggregate: parts[1],
+                entity: parts[2],
+                type: 'entity',
+                fullPath: path
+            };
+        }
+        throw new Error(`Invalid domain path format: ${path}. Expected: module, module.aggregate, or module.aggregate.entity`);
+    }
+    //#endregion
+    //#region ----   Loader Management   ----
+    /**
+     * Register a domain loader for on-demand loading
+     *
+     * @param loader The loader instance to register
+     */
+    addLoader(loader) {
+        this._loaders.push(loader);
+        // Sort by priority (highest first) after adding
+        this._loaders.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    /**
+     * Load definition from registered loaders using first-wins strategy
+     *
+     * @param path Domain path to load
+     * @param type Type of domain object
+     * @returns Promise that resolves to definition or undefined
+     */
+    async loadFromLoaders(path, type) {
+        for (const loader of this._loaders) {
+            if (loader.canLoad(path, type)) {
+                try {
+                    const definition = await loader.load(path, type);
+                    if (definition) {
+                        console.log(`✓ Loaded ${path} from ${loader.constructor.name}`);
+                        return definition; // Return first successful result
+                    }
+                }
+                catch (error) {
+                    console.warn(`⚠ Loader ${loader.constructor.name} failed for ${path}:`, error);
+                    // Continue to next loader instead of throwing
+                }
+            }
+        }
+        return undefined; // No loader could provide the definition
+    }
+    //#endregion
+    //#region ----   Middleware Management   ----
+    /**
+     * Add middleware for module processing
+     */
+    addModuleMiddleware(middleware) {
+        this._moduleMiddleware.push(middleware);
+    }
+    /**
+     * Add middleware for aggregate processing
+     */
+    addAggregateMiddleware(middleware) {
+        this._aggregateMiddleware.push(middleware);
+    }
+    /**
+     * Add middleware for entity processing
+     */
+    addEntityMiddleware(middleware) {
+        this._entityMiddleware.push(middleware);
+    }
+    /**
+     * Apply type-specific middleware to definition
+     *
+     * @param definition Raw definition from cache or loader
+     * @param type Type of domain object
+     * @param path Original path for context
+     * @returns Processed definition
+     */
+    async applyTypeMiddleware(definition, type, path) {
+        const middleware = this.getMiddlewareForType(type);
+        if (middleware.length === 0) {
+            return definition; // No middleware to apply
+        }
+        const context = new AXPDomainMiddlewareContext(definition, type);
+        // Apply all middleware for this type
+        for (const mw of middleware) {
+            await mw(context);
+        }
+        return context.definition;
+    }
+    /**
+     * Get middleware collection for specific type
+     *
+     * @param type Domain object type
+     * @returns Array of middleware functions
+     */
+    getMiddlewareForType(type) {
+        switch (type) {
+            case 'module': return this._moduleMiddleware;
+            case 'aggregate': return this._aggregateMiddleware;
+            case 'entity': return this._entityMiddleware;
+            default: return [];
+        }
+    }
+    //#endregion
+    //#region ----   Model Creation   ----
+    /**
+ * Create domain model from processed definition
+ *
+ * @param definition Processed definition (after middleware)
+ * @param pathInfo Parsed path information
+ * @returns Created domain model
+ */
+    createModel(definition, pathInfo) {
+        switch (pathInfo.type) {
+            case 'module':
+                return new AXPModuleModel(definition);
+            case 'aggregate':
+                // For aggregate, we need to resolve parent module first
+                // This will be simplified when we refactor the models
+                const moduleDefinition = {
+                    name: pathInfo.module,
+                    title: pathInfo.module,
+                    aggregates: [definition]
+                };
+                const parentModule = new AXPModuleModel(moduleDefinition);
+                return new AXPAggregateModel(definition, parentModule);
+            case 'entity':
+                // For entity, we need both module and aggregate parents
+                // This will be simplified when we refactor the models
+                const entityAggregateDefinition = {
+                    name: pathInfo.aggregate,
+                    title: pathInfo.aggregate || '',
+                    entities: [definition],
+                    relations: [],
+                    validations: [],
+                    actions: []
+                };
+                const entityModuleDefinition = {
+                    name: pathInfo.module,
+                    title: pathInfo.module,
+                    aggregates: [entityAggregateDefinition]
+                };
+                const entityModule = new AXPModuleModel(entityModuleDefinition);
+                const entityAggregate = new AXPAggregateModel(entityAggregateDefinition, entityModule);
+                return new AXPEntityModel(definition, entityAggregate, this.schemaService);
+            default:
+                throw new Error(`Unknown domain type: ${pathInfo.type}`);
+        }
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /**
+     * Clear definition cache for a specific path
+     *
+     * @param path Path to clear from cache
+     */
+    invalidateCache(path) {
+        this._definitionCache.delete(path);
+    }
+    /**
+     * Clear all cached definitions
+     */
+    clearCache() {
+        this._definitionCache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this._definitionCache.size,
+            paths: Array.from(this._definitionCache.keys())
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----   Domain Service   ----
+/**
+ * High-level facade service for domain operations.
+ *
+ * Provides simplified interfaces to the domain registry with additional
+ * business logic and convenience methods for common operations.
+ *
+ * This service acts as the main entry point for domain model resolution
+ * and provides a clean API for consuming applications.
+ */
+class AXPDomainService {
+    constructor() {
+        // Injected dependencies
+        this.registry = inject(AXPDomainRegistry);
+    }
+    //#region ----   Module Operations   ----
+    /**
+     * Get module by name
+     *
+     * @param name Module name
+     * @returns Promise that resolves to module model
+     */
+    async getModule(name) {
+        return this.registry.resolve(name);
+    }
+    /**
+     * Check if module exists
+     *
+     * @param name Module name
+     * @returns Promise that resolves to boolean
+     */
+    async moduleExists(name) {
+        try {
+            await this.getModule(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    //#endregion
+    //#region ----   Aggregate Operations   ----
+    /**
+     * Get aggregate by module and aggregate names
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @returns Promise that resolves to aggregate model
+     */
+    async getAggregate(moduleName, aggregateName) {
+        const path = `${moduleName}.${aggregateName}`;
+        return this.registry.resolve(path);
+    }
+    /**
+     * Get aggregate by path
+     *
+     * @param path Aggregate path (module.aggregate)
+     * @returns Promise that resolves to aggregate model
+     */
+    async getAggregateByPath(path) {
+        return this.registry.resolve(path);
+    }
+    /**
+     * Check if aggregate exists
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @returns Promise that resolves to boolean
+     */
+    async aggregateExists(moduleName, aggregateName) {
+        try {
+            await this.getAggregate(moduleName, aggregateName);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    //#endregion
+    //#region ----   Entity Operations   ----
+    /**
+     * Get entity by full path
+     *
+     * @param path Full entity path (module.aggregate.entity)
+     * @returns Promise that resolves to entity model
+     */
+    async getEntity(path) {
+        return this.registry.resolve(path);
+    }
+    /**
+     * Get entity by component parts
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @param entityName Entity name
+     * @returns Promise that resolves to entity model
+     */
+    async getEntityByParts(moduleName, aggregateName, entityName) {
+        const path = `${moduleName}.${aggregateName}.${entityName}`;
+        return this.getEntity(path);
+    }
+    /**
+     * Check if entity exists
+     *
+     * @param path Full entity path
+     * @returns Promise that resolves to boolean
+     */
+    async entityExists(path) {
+        try {
+            await this.getEntity(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    //#endregion
+    //#region ----   Batch Operations   ----
+    /**
+     * Get multiple modules in parallel
+     *
+     * @param moduleNames Array of module names
+     * @returns Promise that resolves to array of module models
+     */
+    async getModules(moduleNames) {
+        return Promise.all(moduleNames.map(name => this.getModule(name)));
+    }
+    /**
+     * Get multiple aggregates in parallel
+     *
+     * @param aggregatePaths Array of aggregate paths
+     * @returns Promise that resolves to array of aggregate models
+     */
+    async getAggregates(aggregatePaths) {
+        return Promise.all(aggregatePaths.map(path => this.getAggregateByPath(path)));
+    }
+    /**
+     * Get multiple entities in parallel
+     *
+     * @param entityPaths Array of entity paths
+     * @returns Promise that resolves to array of entity models
+     */
+    async getEntities(entityPaths) {
+        return Promise.all(entityPaths.map(path => this.getEntity(path)));
+    }
+    //#endregion
+    //#region ----   Search and Discovery   ----
+    /**
+     * Find entities by name across all loaded modules
+     *
+     * @param entityName Entity name to search for
+     * @returns Promise that resolves to array of matching entity paths
+     */
+    async findEntitiesByName(entityName) {
+        // This would require additional registry functionality
+        // For now, return empty array as placeholder
+        return [];
+    }
+    /**
+     * Get all aggregates for a module
+     *
+     * @param moduleName Module name
+     * @returns Promise that resolves to array of aggregate models
+     */
+    async getModuleAggregates(moduleName) {
+        const module = await this.getModule(moduleName);
+        return module.getAllAggregates();
+    }
+    /**
+     * Get all entity references for an aggregate
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @returns Promise that resolves to entity references map
+     */
+    async getAggregateEntityReferences(moduleName, aggregateName) {
+        const aggregate = await this.getAggregate(moduleName, aggregateName);
+        return aggregate.entityReferences;
+    }
+    //#endregion
+    //#region ----   Validation Operations   ----
+    /**
+     * Validate module and all its components
+     *
+     * @param moduleName Module name
+     * @returns Promise that resolves to validation errors array
+     */
+    async validateModule(moduleName) {
+        try {
+            const module = await this.getModule(moduleName);
+            return module.validate();
+        }
+        catch (error) {
+            return [`Failed to load module '${moduleName}': ${error instanceof Error ? error.message : 'Unknown error'}`];
+        }
+    }
+    /**
+     * Validate aggregate and its components
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @returns Promise that resolves to validation errors array
+     */
+    async validateAggregate(moduleName, aggregateName) {
+        try {
+            const aggregate = await this.getAggregate(moduleName, aggregateName);
+            return aggregate.validate();
+        }
+        catch (error) {
+            return [`Failed to load aggregate '${moduleName}.${aggregateName}': ${error instanceof Error ? error.message : 'Unknown error'}`];
+        }
+    }
+    //#endregion
+    //#region ----   Utility Operations   ----
+    /**
+     * Get statistics for a module
+     *
+     * @param moduleName Module name
+     * @returns Promise that resolves to module statistics
+     */
+    async getModuleStatistics(moduleName) {
+        const module = await this.getModule(moduleName);
+        return module.getStatistics();
+    }
+    /**
+     * Get statistics for an aggregate
+     *
+     * @param moduleName Module name
+     * @param aggregateName Aggregate name
+     * @returns Promise that resolves to aggregate statistics
+     */
+    async getAggregateStatistics(moduleName, aggregateName) {
+        const aggregate = await this.getAggregate(moduleName, aggregateName);
+        return aggregate.getStatistics();
+    }
+    /**
+     * Clear registry cache
+     */
+    clearCache() {
+        this.registry.clearCache();
+    }
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache statistics object
+     */
+    getCacheStatistics() {
+        return this.registry.getCacheStats();
+    }
+    /**
+     * Invalidate cache for specific path
+     *
+     * @param path Domain path to invalidate
+     */
+    invalidateCache(path) {
+        this.registry.invalidateCache(path);
+    }
+    //#endregion
+    //#region ----   Helper Methods   ----
+    /**
+     * Parse domain path into components
+     *
+     * @param path Domain path to parse
+     * @returns Parsed path components
+     */
+    parsePath(path) {
+        const parts = path.split('.');
+        if (parts.length === 1) {
+            return { module: parts[0], type: 'module' };
+        }
+        else if (parts.length === 2) {
+            return { module: parts[0], aggregate: parts[1], type: 'aggregate' };
+        }
+        else if (parts.length === 3) {
+            return { module: parts[0], aggregate: parts[1], entity: parts[2], type: 'entity' };
+        }
+        throw new Error(`Invalid domain path format: ${path}`);
+    }
+    /**
+     * Build path from components
+     *
+     * @param module Module name
+     * @param aggregate Aggregate name (optional)
+     * @param entity Entity name (optional)
+     * @returns Built path string
+     */
+    buildPath(module, aggregate, entity) {
+        if (entity && aggregate) {
+            return `${module}.${aggregate}.${entity}`;
+        }
+        else if (aggregate) {
+            return `${module}.${aggregate}`;
+        }
+        else {
+            return module;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXPDomainService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#endregion
+
+//#endregion
+//#region ----   Provider Functions   ----
+/**
+ * Provide domain loaders for on-demand domain loading.
+ *
+ * Domain loaders enable the registry to load domain definitions that are not registered
+ * at build time. This is useful for:
+ * - Loading domain definitions from external APIs
+ * - Dynamic domain generation
+ * - Lazy loading of large domain sets
+ * - Development-time domain hot-reloading
+ *
+ * @param loaders Array of loader classes, instances, or loader configurations
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * // Simple loader registration
+ * provideDomainLoaders([
+ *   HttpDomainLoader,
+ *   FileSystemDomainLoader,
+ *   new MemoryDomainLoader()
+ * ])
+ *
+ * // With priority configuration
+ * provideDomainLoaders([
+ *   { loader: HttpDomainLoader, priority: 10 },
+ *   { loader: FileSystemDomainLoader, priority: 5 },
+ *   { loader: new MemoryDomainLoader(), priority: 15 }
+ * ])
+ * ```
+ */
+function provideDomainLoaders(loaders) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_DOMAIN_LOADER_SETUP,
+            useFactory: async () => {
+                const registry = inject(AXPDomainRegistry);
+                if (!registry) {
+                    console.warn('Domain registry not available during loader setup');
+                    return false;
+                }
+                // Register each loader with the registry
+                for (const loaderConfig of loaders) {
+                    try {
+                        let loaderInstance;
+                        let priority;
+                        if (typeof loaderConfig === 'function') {
+                            // Type<AXPDomainLoader>
+                            loaderInstance = new loaderConfig();
+                            priority = loaderInstance.priority;
+                        }
+                        else if (typeof loaderConfig === 'object' && 'canLoad' in loaderConfig) {
+                            // AXPDomainLoader instance
+                            loaderInstance = loaderConfig;
+                            priority = loaderInstance.priority;
+                        }
+                        else if (typeof loaderConfig === 'object' && 'loader' in loaderConfig) {
+                            // AXPDomainLoaderConfig
+                            if (typeof loaderConfig.loader === 'function') {
+                                loaderInstance = new loaderConfig.loader();
+                            }
+                            else {
+                                loaderInstance = loaderConfig.loader;
+                            }
+                            priority = loaderConfig.priority ?? loaderInstance.priority;
+                        }
+                        else {
+                            console.warn('Invalid loader configuration:', loaderConfig);
+                            continue;
+                        }
+                        // Apply custom priority if specified
+                        if (priority !== undefined && priority !== loaderInstance.priority) {
+                            loaderInstance.priority = priority;
+                        }
+                        registry.addLoader(loaderInstance);
+                        console.log(`✓ Registered domain loader: ${loaderInstance.constructor.name} (priority: ${loaderInstance.priority ?? 0})`);
+                    }
+                    catch (error) {
+                        console.error('Failed to register domain loader:', error);
+                    }
+                }
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+/**
+ * Provide a single domain loader for convenience
+ *
+ * @param loader Loader class, instance, or configuration
+ * @returns Environment providers for dependency injection
+ */
+function provideDomainLoader(loader) {
+    return provideDomainLoaders([loader]);
+}
+//#endregion
+
+//#region ----   Injection Tokens   ----
+/**
+ * Injection tokens for type-specific middleware setup
+ */
+const AXP_MODULE_MIDDLEWARE_SETUP = 'AXP_MODULE_MIDDLEWARE_SETUP';
+const AXP_AGGREGATE_MIDDLEWARE_SETUP = 'AXP_AGGREGATE_MIDDLEWARE_SETUP';
+const AXP_ENTITY_MIDDLEWARE_SETUP = 'AXP_ENTITY_MIDDLEWARE_SETUP';
+//#endregion
+//#region ----   Provider Functions   ----
+/**
+ * Provide middleware for module processing.
+ *
+ * Module middleware is applied when resolving module definitions and can:
+ * - Add metadata and custom properties
+ * - Validate module structure
+ * - Transform module definitions
+ * - Add computed properties
+ *
+ * @param middleware Array of middleware functions to register
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideModuleMiddleware([
+ *   (context) => {
+ *     // Add common module metadata
+ *     context.setMetadata('loadedAt', new Date());
+ *     context.setMetadata('version', '1.0.0');
+ *   },
+ *   (context) => {
+ *     // Add namespace prefix if not present
+ *     if (!context.definition.name.includes('.')) {
+ *       context.definition.name = `app.${context.definition.name}`;
+ *     }
+ *   }
+ * ])
+ * ```
+ */
+function provideModuleMiddleware(middleware) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_MODULE_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                // Access registry through DI when available
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during module middleware setup');
+                    return false;
+                }
+                // Register all module middleware
+                for (const mw of middleware) {
+                    registry.addModuleMiddleware(mw);
+                }
+                console.log(`✓ Registered ${middleware.length} module middleware functions`);
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+/**
+ * Provide middleware for aggregate processing.
+ *
+ * Aggregate middleware is applied when resolving aggregate definitions and can:
+ * - Add metadata and custom properties
+ * - Validate aggregate structure
+ * - Transform entity references
+ * - Add computed relations
+ *
+ * @param middleware Array of middleware functions to register
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideAggregateMiddleware([
+ *   (context) => {
+ *     // Add aggregate metadata
+ *     context.setMetadata('type', 'business-aggregate');
+ *   },
+ *   (context) => {
+ *     // Validate entity references
+ *     const entities = context.definition.entities;
+ *     if (Object.keys(entities).length === 0) {
+ *       throw new Error('Aggregate must have at least one entity');
+ *     }
+ *   }
+ * ])
+ * ```
+ */
+function provideAggregateMiddleware(middleware) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_AGGREGATE_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                // Access registry through DI when available
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during aggregate middleware setup');
+                    return false;
+                }
+                // Register all aggregate middleware
+                for (const mw of middleware) {
+                    registry.addAggregateMiddleware(mw);
+                }
+                console.log(`✓ Registered ${middleware.length} aggregate middleware functions`);
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+/**
+ * Provide middleware for entity processing.
+ *
+ * Entity middleware is applied when resolving entity definitions and can:
+ * - Add auto-generated fields (id, timestamps)
+ * - Apply field transformations
+ * - Add validation rules
+ * - Set default values
+ *
+ * @param middleware Array of middleware functions to register
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideEntityMiddleware([
+ *   (context) => {
+ *     // Add auto-generated ID field if not present
+ *     if (!context.definition.fields.some(f => f.name === 'id')) {
+ *       context.addField({
+ *         name: 'id',
+ *         type: 'uuid',
+ *         required: true,
+ *         generated: true
+ *       });
+ *     }
+ *   },
+ *   (context) => {
+ *     // Add timestamp fields
+ *     context.addField({
+ *       name: 'createdAt',
+ *       type: 'datetime',
+ *       required: true,
+ *       generated: true
+ *     });
+ *     context.addField({
+ *       name: 'updatedAt',
+ *       type: 'datetime',
+ *       required: true,
+ *       generated: true
+ *     });
+ *   }
+ * ])
+ * ```
+ */
+function provideEntityMiddleware(middleware) {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_ENTITY_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                // Access registry through DI when available
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during entity middleware setup');
+                    return false;
+                }
+                // Register all entity middleware
+                for (const mw of middleware) {
+                    registry.addEntityMiddleware(mw);
+                }
+                console.log(`✓ Registered ${middleware.length} entity middleware functions`);
+                return true;
+            },
+            multi: true
+        }
+    ]);
+}
+/**
+ * Provide combined middleware for all domain types.
+ *
+ * This is a convenience function that allows registering middleware for multiple
+ * domain types in a single call.
+ *
+ * @param config Configuration object with middleware for each type
+ * @returns Environment providers for dependency injection
+ *
+ * @example
+ * ```typescript
+ * provideDomainMiddleware({
+ *   modules: [
+ *     (context) => context.setMetadata('loadedAt', new Date())
+ *   ],
+ *   aggregates: [
+ *     (context) => context.setMetadata('type', 'business-aggregate')
+ *   ],
+ *   entities: [
+ *     (context) => {
+ *       if (!context.definition.fields.some(f => f.name === 'id')) {
+ *         context.addField({ name: 'id', type: 'uuid', required: true });
+ *       }
+ *     }
+ *   ]
+ * })
+ * ```
+ */
+function provideDomainMiddleware(config) {
+    const allProviders = [];
+    // Add module middleware providers
+    if (config.modules && config.modules.length > 0) {
+        allProviders.push({
+            provide: AXP_MODULE_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during module middleware setup');
+                    return false;
+                }
+                for (const mw of config.modules) {
+                    registry.addModuleMiddleware(mw);
+                }
+                return true;
+            },
+            multi: true
+        });
+    }
+    // Add aggregate middleware providers
+    if (config.aggregates && config.aggregates.length > 0) {
+        allProviders.push({
+            provide: AXP_AGGREGATE_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during aggregate middleware setup');
+                    return false;
+                }
+                for (const mw of config.aggregates) {
+                    registry.addAggregateMiddleware(mw);
+                }
+                return true;
+            },
+            multi: true
+        });
+    }
+    // Add entity middleware providers
+    if (config.entities && config.entities.length > 0) {
+        allProviders.push({
+            provide: AXP_ENTITY_MIDDLEWARE_SETUP,
+            useFactory: () => {
+                const registry = globalThis.__domainRegistry__;
+                if (!registry) {
+                    console.warn('Domain registry not available during entity middleware setup');
+                    return false;
+                }
+                for (const mw of config.entities) {
+                    registry.addEntityMiddleware(mw);
+                }
+                return true;
+            },
+            multi: true
+        });
+    }
+    return makeEnvironmentProviders(allProviders);
+}
+//#endregion
+
+//#region ----   Core Registry System   ----
+// Main registry and service
+//#endregion
+
+//#endregion
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXPDomainModule, AXP_ENTITY_CRUD_SETUP, provideEntity };
+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