@acorex/platform 20.8.12 → 20.8.14

package/{types/acorex-platform-domain.d.ts → domain/index.d.ts}

@@ -1,20 +1,38 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Type, EnvironmentProviders } from '@angular/core';
-import { AXPExpression, AXPMetaData, AXPDataType, AXPOptionsData, AXPDefinitionCategory, AXPValidationRules } from '@acorex/platform/core';
+import { InjectionToken, EnvironmentProviders, Type } from '@angular/core';
 import * as i1 from '@acorex/platform/runtime';
+import { AXPExpression, AXPValidationRules, AXPOptionsData, AXPMetaData } from '@acorex/platform/core';
 
-/**
- * Token for entity CRUD setup. Consumed by AXPDomainModule.
- * The actual provider is provideEntity() from @acorex/platform/layout/entity
- * to avoid circular dependency (domain must not depend on layout/entity).
- */
 declare const AXP_ENTITY_CRUD_SETUP: InjectionToken<void>;
+declare function provideEntity(entityKeys: string[]): EnvironmentProviders;
 
-declare enum AXPDomainActionSide {
-    Client = "client",
-    Server = "server",
-    Both = "both"
+declare class AXPDomainModule {
+    private _commandSetup;
+    /**
+     * 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.
+     */
+    private _schemaSetup;
+    private _schemaMiddlewareSetup;
+    private _schemaLoaderSetup;
+    /**
+     * 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.
+     */
+    private _domainLoaderSetup;
+    private _domainMiddlewareSetup;
+    private _domainSetup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDomainModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPDomainModule, never, [typeof i1.AXPRuntimeModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPDomainModule>;
 }
+
 /**
  * Interface for defining actions
  */
@@ -30,124 +48,31 @@ declare enum AXPEntityCommandScope {
     Individual = "individual",
     Section = "section"
 }
-interface AXPDomainRealtedModuleEntity {
-    moduleId?: string;
-    module?: {
-        id?: string;
-        name?: string;
-        title?: string;
-    };
-    entityId?: string;
-    entity?: {
-        id?: string;
-        name?: string;
-        title?: string;
-    };
-}
-
-/**
- * Where the validation rule runs: client-side only, server-side only, or both.
- */
-type AXPValidationRunAt = 'client' | 'server' | 'both';
-/**
- * Validation rule definition (catalog model): metadata for available validation rules.
- * Used in UI to list validation rules: name (rule key), title, description, and runAt.
- * The actual rule usage on properties uses AXPValidationRule from @acorex/platform/core.
- */
-interface AXPValidationRuleDefinition extends AXPDomainRealtedModuleEntity {
-    rule: string;
-    title: string;
-    description?: string;
-    icon?: string;
-    /** Where the validation runs: client-side, server-side, or both. Default: 'client' */
-    runAt?: AXPValidationRunAt;
-    message?: string;
-    options?: AXPPropertyDefinition[];
-}
-interface AXPValidationRuleValue {
-    rule: string;
-    title?: string;
-    message?: string;
-    options?: AXPMetaData;
-}
 
-interface AXPPropertyFeatures {
-    searchable?: {
-        enabled: boolean;
-        fullText: boolean;
-    };
-    filterable?: {
-        enabled: boolean;
-        inline: boolean;
-    };
-    sortable?: {
-        enabled: boolean;
-    };
-    auditable?: {
-        enabled: boolean;
-    };
-}
-interface AXPPropertyDefinition {
-    name: string;
-    title: string;
-    description?: string;
-    icon?: string;
-    defaultValue?: unknown;
-    disabled?: boolean;
-    dataType?: AXPDataType;
-    interface: AXPInterfaceDefinitionValue;
-    validations?: AXPValidationRuleValue[];
-    features?: AXPPropertyFeatures;
-    metadata?: AXPMetaData;
+declare enum AXPEntityType {
+    Entity = 0,
+    AggregateRoot = 1,
+    ValueObject = 2
 }
-
-/** Widget category for interface grouping (e.g. Editors, Layout, Action). */
-interface AXPInterfaceCategory {
+interface AXPEntityDefinition {
     name: string;
     title: string;
-    order?: number;
-}
-/** Widget interface definition stored in DB (display metadata + option definitions). Values are stored in schema. */
-interface AXPInterfaceDefinition {
-    name: string;
-    title?: string;
-    description?: string;
-    icon?: string;
-    dataType?: AXPDataType;
-    /** Widget categories (e.g. Editors, Layout). */
-    categories?: AXPInterfaceCategory | AXPInterfaceCategory[];
-    /** Widget groups (e.g. form-element, entity-widget). */
-    groups?: string[];
-    /** Widget type: editor, view, filter, container, action, etc. */
-    type?: string;
-    /** Default filter widget name when used as filter (e.g. string-filter, number-filter). */
-    defaultFilterWidgetName?: string;
-    optionDefinitions?: AXPPropertyDefinition[];
+    fields: AXPEntityFieldDefinition[];
+    type: AXPEntityType;
 }
-interface AXPInterfaceDefinitionValue {
-    name: string;
-    title: string;
-    options?: AXPOptionsData;
+interface AXPEntityFieldFeatures {
+    nullable: boolean;
+    readOnly: boolean;
 }
-
-/**
- * Plugin definition (catalog model): metadata for available plugins.
- * Used in UI to list plugins: name, title, optional icon, description, and options schema.
- */
-interface AXPPluginDefinition extends AXPDomainRealtedModuleEntity {
+interface AXPEntityFieldDefinition {
     name: string;
     title: string;
     description?: string;
-    icon?: string;
-    options?: AXPPropertyDefinition[];
-}
-/**
- * Plugin value in entity: name + optional options (key-value).
- * Fills the definition when used on an entity.
- */
-interface AXPPluginDefinitionValue {
-    name: string;
-    options?: AXPMetaData;
+    validations?: AXPValidationRules;
+    actions?: AXPDomainAction[];
+    features?: AXPEntityFieldFeatures;
+    defaultValue?: any;
+    schema: string;
 }
 
 declare enum AXPRelationshipKind {
@@ -161,409 +86,188 @@ declare enum AXPRelationshipCardinality {
     ManyToMany = 2
 }
 /**
- * Standalone relation definition with full source and target.
- * Relations live in their own collection, independent of aggregates.
+ * Interface for defining relationships between aggregates
  */
-interface AXPRelationDefinition {
-    id?: string;
+interface AXPAggregateRelationDefinition {
     type: AXPRelationshipCardinality;
     kind: AXPRelationshipKind;
-    source: {
+    target: {
         aggregate: string;
         entity: string;
         key: string;
     };
-    target: {
-        aggregate: string;
+    source: {
         entity: string;
         key: string;
     };
     isRequired: boolean;
 }
 
-/**
- * Discriminated JSON for `AXPMenuDefinitionRecord.command`.
- * Modal navigation is omitted (Angular `Type` is not JSON-serializable).
- */
-type AXPMenuDefinitionStoredCommand = {
-    kind: 'navigate';
-    navigateType: 'router';
-    path: string;
-    extras?: Record<string, unknown>;
-} | {
-    kind: 'execute';
-    name: string;
-    options?: Record<string, unknown>;
+type AXPAggregateEntityList = {
+    [key: string]: () => Promise<AXPEntityDefinition>;
 };
-/**
- * Optional reference to an entity list route: resolved at runtime via `AXPEntityService.createPath`.
- */
-interface AXPMenuDefinitionEntityListRef {
-    module: string;
-    entity: string;
-}
-/**
- * Serializable menu definition for definition stores (Dexie/Firestore in mock today).
- * Mirrors persisted shape for `AXPEntityDefinitionCrudService` menu APIs — not identical to shell `AXPMenuItem`.
- */
-interface AXPMenuDefinitionRecord {
-    /** Same as `AXPMenuItem.name` (unique key). */
-    name: string;
-    text: string;
-    description?: string;
-    icon?: string;
-    priority?: number;
-    type?: 'menu' | 'group' | 'break';
-    /**
-     * Parent menu `name` for `context.find(attachParentName).addItems(...)`.
-     * Empty omits attachment (provider may add to root — see implementation).
-     */
-    attachParentName?: string;
-    /** Literal router path; if both this and `entityListRef` are set, implementations may prefer this. */
-    path?: string;
-    entityListRef?: AXPMenuDefinitionEntityListRef;
-    policyFeatures?: string[];
-    policyPermissions?: string[];
-    badgeKey?: string;
-    command?: AXPMenuDefinitionStoredCommand;
-    /**
-     * Optional module classification (references `PlatformManagement.ModuleDefinitions` when using the category plugin).
-     */
-    categoryIds?: string[];
-    /** Denormalized labels for list/display (mirrors product category pattern). */
-    categories?: Array<{
-        id: string;
-        title?: string;
-    }>;
-    meta?: Record<string, unknown>;
-}
-
-/**
- * One level of child permissions under a root permission (fluent `addChild` only).
- * Nested `children` under leaves are not part of the storage contract.
- */
-interface AXPPermissionLeafRecord {
-    name: string;
-    title: string;
-    description?: string;
-    requiredFeatures?: string[];
-}
-/**
- * Root permission row: one `addPermission` … `endPermission` chain, with optional sibling `addChild` entries.
- */
-interface AXPPermissionDefinitionRecord {
+interface AXPAggregateDefinition {
     name: string;
     title: string;
-    description?: string;
-    requiredFeatures?: string[];
-    /** At most one level — matches `AXPPermissionDefinitionProviderContext` fluent API. */
-    children?: AXPPermissionLeafRecord[];
+    entities: AXPEntityDefinition[] | AXPAggregateEntityList | Record<string, string>;
+    relations: AXPAggregateRelationDefinition[];
+    validations: AXPValidationRules;
+    actions: AXPDomainAction[];
 }
-/**
- * Serializable permission group for definition stores (Dexie/Firestore).
- * Aligns with `AXPPermissionGroupDefinition` / fluent providers; one row per group.
- */
-interface AXPPermissionGroupDefinitionRecord {
+
+interface AXPModuleDefinition {
     name: string;
     title: string;
-    description?: string;
-    permissions: AXPPermissionDefinitionRecord[];
-    /**
-     * Optional module classification (references `PlatformManagement.ModuleDefinitions` when using the category plugin).
-     */
-    categoryIds?: string[];
-    /** Denormalized labels for list/display (mirrors product category pattern). */
-    categories?: Array<{
-        id: string;
-        title?: string;
-    }>;
+    aggregates: AXPAggregateDefinition[];
 }
 
-/** Surfaces where a command may be exposed (tooling / automation). Build-time: optional on `defineCommand`. */
-type AXPCommandCapability = 'ai' | 'workflow';
-/**
- * Persisted command registry row (e.g. Dexie/Firestore via AXPEntityDefinitionCrudService).
- * `name` is the runtime command key; `active` is the toggle stored for mock/admin UIs.
- */
-interface AXPCommandRegistryRecord {
-    name: string;
-    active: boolean;
-    /** Human / AI-oriented description of what the command does. */
-    description?: string;
-    /** Input parameters as schema rows (same shape as interface `optionDefinitions`). */
-    inputOptionDefinitions?: AXPPropertyDefinition[];
-    /** Output shape as schema rows (same shape as interface `optionDefinitions`). */
-    outputOptionDefinitions?: AXPPropertyDefinition[];
-    /** Display title from build-time command metadata (`*.definition.ts`). */
-    catalogTitle?: string;
-    /** Where the command runs (metadata). */
-    executionMode?: 'frontend' | 'backend' | 'both';
-    /** Pretty-printed JSON of the outcomes definition from metadata (readonly display). */
-    outcomesDefinitionJson?: string;
-    /** Pretty-printed JSON of AI hints from metadata (readonly display). */
-    aiMetadataJson?: string;
-    /**
-     * Optional capability flags (from build-time `capabilities` on command metadata).
-     * Omitted or empty means no declared surface; consumers may still apply legacy rules (e.g. AI `ai-tool` tag).
-     */
-    capabilities?: AXPCommandCapability[];
-    /** Optional grouping from build-time command metadata (`categories` on `defineCommand`). */
-    categories?: AXPDefinitionCategory[];
+type AXPSchemaDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'blob';
+interface AXPSchemaInterface {
+    widget: string;
+    options?: AXPOptionsData;
+    disabled?: boolean;
 }
-
-/**
- * Persisted query registry row (e.g. Dexie/Firestore via AXPEntityDefinitionCrudService).
- * `name` is the runtime query key; `active` is the toggle stored for mock/admin UIs.
- * Queries expose `fetch(input)` only — no command outcomes.
- */
-interface AXPQueryRegistryRecord {
-    name: string;
-    active: boolean;
-    /** Human / AI-oriented description of what the query returns. */
-    description?: string;
-    /** Input parameters (filter / criteria) as property definition rows. */
-    inputOptionDefinitions?: AXPPropertyDefinition[];
-    /** Result shape as property definition rows (documentation / tooling). */
-    outputOptionDefinitions?: AXPPropertyDefinition[];
-    /** Display title from build-time query metadata (`*.query.definition.ts`). */
-    catalogTitle?: string;
-    /** Where the query runs (metadata). */
-    executionMode?: 'frontend' | 'backend' | 'both';
-    /** Pretty-printed JSON of AI hints from metadata (readonly display). */
-    aiMetadataJson?: string;
-    /**
-     * Optional capability flags (from build-time `capabilities` on query metadata).
-     * Omitted or empty means no declared surface; consumers may still apply legacy rules (e.g. AI `ai-tool` tag).
-     */
-    capabilities?: AXPCommandCapability[];
-    /** Optional grouping from build-time query metadata (`categories` on `defineQuery`). */
-    categories?: AXPDefinitionCategory[];
+interface AXPSchemaFeatures {
+    searchable?: {
+        enabled: boolean;
+        fullText: boolean;
+    };
+    filterable?: {
+        enabled: boolean;
+        inline: boolean;
+    };
+    sortable?: {
+        enabled: boolean;
+    };
+    auditable?: {
+        enabled: boolean;
+    };
 }
-
-/**
- * Persisted layout-widget catalog row (Dexie/Firestore via AXPEntityDefinitionCrudService).
- * `name` is the widget registry name from build-time `defineWidget` metadata; `metadataJson` holds the full payload.
- */
-interface AXPWidgetCatalogRecord {
+interface AXPSchemaDefinition {
     name: string;
-    active: boolean;
-    description?: string;
-    /** Localized / catalog title from metadata `title`. */
-    catalogTitle?: string;
-    /** Pretty-printed JSON of full widget metadata (`defineWidget` sidecar). */
-    metadataJson?: string;
+    dataType: AXPSchemaDataType;
+    interface: AXPSchemaInterface;
+    validations?: AXPValidationRules;
+    features?: AXPSchemaFeatures;
+    metadata?: AXPMetaData;
 }
 
 /**
- * Service interface for CRUD operations on entity and related definition records stored in Dexie/Firestore.
- * Provided by connectivity mock when using Dexie or Firestore as entity definition source.
- * Use this service from anywhere in the app (not just mock).
+ * Runtime model for relation definitions with parent references and helper methods
  */
-interface AXPEntityDefinitionCrudService {
-    list(): Promise<{
-        name: string;
-        module: string;
-        entityName?: string;
-    }[]>;
-    getRaw(moduleName: string, entityName: string): Promise<Record<string, unknown> | null>;
-    create(entityName: string, definition: Record<string, unknown>): Promise<void>;
-    update(entityName: string, definition: Record<string, unknown>): Promise<void>;
-    delete(entityName: string): Promise<void>;
-    listInterfaces(): Promise<AXPInterfaceDefinition[]>;
-    listInterfacesByCategory(categoryName: string): Promise<AXPInterfaceDefinition[]>;
-    getInterface(name: string): Promise<AXPInterfaceDefinition | null>;
-    createInterface(name: string, definition: AXPInterfaceDefinition): Promise<void>;
-    updateInterface(name: string, definition: AXPInterfaceDefinition): Promise<void>;
-    deleteInterface(name: string): Promise<void>;
-    listPlugins(): Promise<AXPPluginDefinition[]>;
-    getPlugin(name: string): Promise<AXPPluginDefinition | null>;
-    createPlugin(name: string, definition: AXPPluginDefinition): Promise<void>;
-    updatePlugin(name: string, definition: AXPPluginDefinition): Promise<void>;
-    deletePlugin(name: string): Promise<void>;
-    listValidations(): Promise<AXPValidationRuleDefinition[]>;
-    getValidation(name: string): Promise<AXPValidationRuleDefinition | null>;
-    createValidation(name: string, definition: AXPValidationRuleDefinition): Promise<void>;
-    updateValidation(name: string, definition: AXPValidationRuleDefinition): Promise<void>;
-    deleteValidation(name: string): Promise<void>;
-    listRelations(): Promise<Array<AXPRelationDefinition & {
-        id: string;
-    }>>;
-    getRelation(id: string): Promise<AXPRelationDefinition | null>;
-    createRelation(id: string, definition: AXPRelationDefinition): Promise<void>;
-    updateRelation(id: string, definition: AXPRelationDefinition): Promise<void>;
-    deleteRelation(id: string): Promise<void>;
-    listModules(): Promise<Array<{
-        name: string;
-        title?: string;
-        icon?: string;
-    }>>;
-    getModule(name: string): Promise<{
-        name: string;
-        title?: string;
-        icon?: string;
-    } | null>;
-    createModule(name: string, definition: {
-        name: string;
-        title?: string;
-        icon?: string;
-    }): Promise<void>;
-    updateModule(name: string, definition: {
-        name: string;
-        title?: string;
-        icon?: string;
-    }): Promise<void>;
-    deleteModule(name: string): Promise<void>;
-    listAggregates(filter?: {
-        module?: string;
-    }): Promise<Array<{
-        id: string;
-        definition: Record<string, unknown>;
-    }>>;
-    getAggregate(id: string): Promise<Record<string, unknown> | null>;
-    createAggregate(id: string, definition: Record<string, unknown>): Promise<void>;
-    updateAggregate(id: string, definition: Record<string, unknown>): Promise<void>;
-    deleteAggregate(id: string): Promise<void>;
-    listMenus(): Promise<Array<{
-        id: string;
-        definition: AXPMenuDefinitionRecord;
-    }>>;
-    getMenu(id: string): Promise<AXPMenuDefinitionRecord | null>;
-    createMenu(id: string, definition: AXPMenuDefinitionRecord): Promise<void>;
-    updateMenu(id: string, definition: AXPMenuDefinitionRecord): Promise<void>;
-    deleteMenu(id: string): Promise<void>;
-    listPermissionGroups(): Promise<Array<{
-        id: string;
-        definition: AXPPermissionGroupDefinitionRecord;
-    }>>;
-    getPermissionGroup(id: string): Promise<AXPPermissionGroupDefinitionRecord | null>;
-    createPermissionGroup(id: string, definition: AXPPermissionGroupDefinitionRecord): Promise<void>;
-    updatePermissionGroup(id: string, definition: AXPPermissionGroupDefinitionRecord): Promise<void>;
-    deletePermissionGroup(id: string): Promise<void>;
-    listCommands(): Promise<Array<{
-        id: string;
-        definition: AXPCommandRegistryRecord;
-    }>>;
-    getCommand(id: string): Promise<AXPCommandRegistryRecord | null>;
-    createCommand(id: string, definition: AXPCommandRegistryRecord): Promise<void>;
-    updateCommand(id: string, definition: AXPCommandRegistryRecord): Promise<void>;
-    deleteCommand(id: string): Promise<void>;
-    listQueries(): Promise<Array<{
-        id: string;
-        definition: AXPQueryRegistryRecord;
-    }>>;
-    getQuery(id: string): Promise<AXPQueryRegistryRecord | null>;
-    createQuery(id: string, definition: AXPQueryRegistryRecord): Promise<void>;
-    updateQuery(id: string, definition: AXPQueryRegistryRecord): Promise<void>;
-    deleteQuery(id: string): Promise<void>;
-    listWidgets(): Promise<Array<{
-        id: string;
-        definition: AXPWidgetCatalogRecord;
-    }>>;
-    getWidget(id: string): Promise<AXPWidgetCatalogRecord | null>;
-    createWidget(id: string, definition: AXPWidgetCatalogRecord): Promise<void>;
-    updateWidget(id: string, definition: AXPWidgetCatalogRecord): Promise<void>;
-    deleteWidget(id: string): Promise<void>;
-}
-declare const AXP_ENTITY_DEFINITION_CRUD_SERVICE: InjectionToken<AXPEntityDefinitionCrudService | null>;
-
-declare class AXPDomainModule {
-    private _commandSetup;
+declare class AXPRelationModel {
+    readonly type: AXPRelationshipCardinality;
+    readonly kind: AXPRelationshipKind;
+    readonly target: {
+        aggregate: string;
+        entity: string;
+        key: string;
+    };
+    readonly source: {
+        entity: string;
+        key: string;
+    };
+    readonly isRequired: boolean;
+    readonly parent: any;
+    constructor(definition: AXPAggregateRelationDefinition, parent: any);
     /**
-     * Optional bootstrap hooks for registered property definitions (see {@link AXP_PROPERTY_SETUP} and related tokens).
+     * Check if relation is one-to-one
      */
-    private _propertySetup;
-    private _propertyMiddlewareSetup;
-    private _propertyLoaderSetup;
+    isOneToOne(): boolean;
     /**
-     * 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.
+     * Check if relation is one-to-many
      */
-    private _domainLoaderSetup;
-    private _domainMiddlewareSetup;
-    private _domainSetup;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDomainModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPDomainModule, never, [typeof i1.AXPRuntimeModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXPDomainModule>;
-}
-
-declare enum AXPEntityType {
-    Entity = 0,
-    AggregateRoot = 1,
-    ValueObject = 2
-}
-interface AXPEntityDefinition {
-    name: string;
-    title: string;
-    fields: AXPEntityPropertyDefinition[];
-    type: AXPEntityType;
-    /** Entity plugins (e.g. common.history, common.lock). Name + optional options only. */
-    plugins?: AXPPluginDefinitionValue[];
-    /** Property groups for layout */
-    groups?: Array<{
-        id: string;
-        title: string;
-    }>;
-    /** List/table columns */
-    columns?: Array<{
-        name: string;
-    }>;
-    /** Display formats */
-    formats?: {
-        individual?: string;
-        plural?: string;
+    isOneToMany(): boolean;
+    /**
+     * Check if relation is many-to-many
+     */
+    isManyToMany(): boolean;
+    /**
+     * Check if relation is association
+     */
+    isAssociation(): boolean;
+    /**
+     * Check if relation is composition
+     */
+    isComposition(): boolean;
+    /**
+     * Check if relation is aggregation
+     */
+    isAggregation(): boolean;
+    /**
+     * Get parent aggregate
+     */
+    getAggregate(): any;
+    /**
+     * Get parent module
+     */
+    getModule(): any;
+    /**
+     * Get full path (module.aggregate.relation)
+     */
+    getPath(): string;
+    /**
+     * Get relation description
+     */
+    getDescription(): string;
+    /**
+     * Get cardinality description
+     */
+    getCardinalityDescription(): string;
+    /**
+     * Get kind description
+     */
+    getKindDescription(): string;
+    /**
+     * Get relation summary
+     */
+    getSummary(): string;
+    /**
+     * Validate the relation structure
+     */
+    validate(): string[];
+    /**
+     * Get relation characteristics
+     */
+    getCharacteristics(): {
+        type: string;
+        kind: string;
+        required: boolean;
+        isOwning: boolean;
+        isNavigable: boolean;
     };
-    /** Layout interfaces (master create/update/single/list). Pass-through for converter. */
-    interfaces?: Record<string, unknown>;
-    /** Module name (e.g. ContentManagement). Derived from path or explicit. */
-    module?: string;
-    /** Entity icon. */
-    icon?: string;
-}
-interface AXPEntityPropertyFeatures {
-    nullable: boolean;
-    readOnly: boolean;
-}
-/**
- * Entity field: flattened embedded property definition (interface, validations, features) plus entity-only metadata.
- * Top-level name/title are the entity property name/title.
- */
-interface AXPEntityPropertyDefinition extends AXPPropertyDefinition {
-    actions?: AXPDomainAction[];
-    /** Nullable/readOnly for entity binding; distinct from property.features (searchable, filterable, etc.). */
-    fieldFeatures?: AXPEntityPropertyFeatures;
-}
-
-type AXPAggregateEntityList = {
-    [key: string]: () => Promise<AXPEntityDefinition>;
-};
-/**
- * Aggregate definition. Relations are stored in a separate collection (like MySQL join table).
- * Join when needed via relations collection.
- */
-interface AXPAggregateDefinition {
-    name: string;
-    title: string;
-    entities: AXPEntityDefinition[] | AXPAggregateEntityList | Record<string, string>;
-    validations: AXPValidationRules;
-    actions: AXPDomainAction[];
-}
-
-interface AXPModuleDefinition {
-    name: string;
-    title: string;
-    aggregates: AXPAggregateDefinition[];
+    /**
+     * Check if relation involves entity
+     */
+    involvesEntity(entityName: string): boolean;
+    /**
+     * Check if relation targets aggregate
+     */
+    targetsAggregate(aggregateName: string): boolean;
+    /**
+     * Get the other entity in the relation
+     */
+    getOtherEntity(entityName: string): string | null;
+    /**
+     * Convert back to interface definition
+     */
+    toDefinition(): AXPAggregateRelationDefinition;
 }
 
 /**
  * Simple runtime model for aggregate definitions with parent references and navigation helpers.
- * Relations are stored in a separate collection; join when needed.
+ *
+ * This model is a pure data structure that provides:
+ * - Access to aggregate properties and metadata
+ * - Navigation helpers for finding relations and entity references
+ * - Parent module reference for hierarchy navigation
+ *
+ * All loading and resolution logic has been moved to AXPDomainRegistry.
  */
 declare class AXPAggregateModel {
     readonly name: string;
     readonly title: string;
+    readonly relations: AXPRelationModel[];
     readonly validations: AXPValidationRules;
     readonly actions: AXPDomainAction[];
     readonly parent: any;
@@ -601,6 +305,21 @@ declare class AXPAggregateModel {
      * @returns True if entity exists
      */
     hasEntity(entityName: string): boolean;
+    /**
+     * 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: string, targetEntity: string): AXPRelationModel | undefined;
+    /**
+     * Get all relations for a specific entity
+     *
+     * @param entityName Entity name
+     * @returns Array of relations involving the entity
+     */
+    getEntityRelations(entityName: string): AXPRelationModel[];
     /**
      * Get parent module
      *
@@ -620,6 +339,7 @@ declare class AXPAggregateModel {
      */
     getStatistics(): {
         entityCount: number;
+        relationCount: number;
         actionCount: number;
         validationCount: number;
     };
@@ -710,8 +430,9 @@ declare class AXPModuleModel {
      */
     getAllEntityReferences(): Record<string, string>;
     /**
-     * Relations are stored in a separate collection. Use relation queries for join when needed.
-     * @deprecated Relations are no longer nested in aggregates.
+     * Get all relations across all aggregates
+     *
+     * @returns Array of all relation models
      */
     getAllRelations(): Array<{
         aggregate: AXPAggregateModel;
@@ -731,6 +452,7 @@ declare class AXPModuleModel {
     getStatistics(): {
         aggregateCount: number;
         entityCount: number;
+        relationCount: number;
         actionCount: number;
         validationCount: number;
     };
@@ -743,27 +465,54 @@ declare class AXPModuleModel {
 }
 
 /**
- * Runtime model for a {@link AXPPropertyDefinition} with helper methods.
+ * Runtime model for schema definitions with helper methods
  */
-declare class AXPPropertyModel {
+declare class AXPSchemaModel {
     readonly name: string;
-    readonly title: string;
-    readonly interface: AXPInterfaceDefinitionValue;
+    readonly dataType: AXPSchemaDataType;
+    readonly interface: AXPSchemaInterface;
     readonly validations: AXPValidationRules;
-    readonly features: AXPPropertyFeatures;
+    readonly features: AXPSchemaFeatures;
     readonly metadata?: AXPMetaData;
-    readonly description?: string;
-    readonly icon?: string;
-    readonly defaultValue?: unknown;
-    readonly disabled?: boolean;
-    readonly dataType: AXPDataType;
-    constructor(definition: AXPPropertyDefinition);
+    constructor(definition: AXPSchemaDefinition);
+    /**
+     * Check if schema is for string data
+     */
+    isString(): boolean;
+    /**
+     * Check if schema is for number data
+     */
+    isNumber(): boolean;
+    /**
+     * Check if schema is for boolean data
+     */
+    isBoolean(): boolean;
+    /**
+     * Check if schema is for date data
+     */
+    isDate(): boolean;
+    /**
+     * Check if schema is for object data
+     */
+    isObject(): boolean;
+    /**
+     * Check if schema is for array data
+     */
+    isArray(): boolean;
+    /**
+     * Check if schema is for blob data
+     */
+    isBlob(): boolean;
+    /**
+     * Get widget type
+     */
+    getWidgetType(): string;
     /**
      * Get widget options
      */
     getWidgetOptions(): AXPOptionsData | undefined;
     /**
-     * Check if the property is disabled
+     * Check if interface is disabled
      */
     isDisabled(): boolean;
     /**
@@ -791,11 +540,11 @@ declare class AXPPropertyModel {
      */
     isAuditable(): boolean;
     /**
-     * Validate the property definition structure
+     * Validate the schema structure
      */
     validate(): Promise<string[]>;
     /**
-     * Get property capabilities
+     * Get schema capabilities
      */
     getCapabilities(): {
         searchable: boolean;
@@ -807,9 +556,10 @@ declare class AXPPropertyModel {
         disabled: boolean;
     };
     /**
-     * Get property summary
+     * Get schema summary
      */
     getSummary(): {
+        dataType: AXPSchemaDataType;
         widget: string;
         hasOptions: boolean;
         hasMetadata: boolean;
@@ -819,26 +569,30 @@ declare class AXPPropertyModel {
     /**
      * Convert back to interface definition
      */
-    toDefinition(): AXPPropertyDefinition;
+    toDefinition(): AXPSchemaDefinition;
 }
 
 /**
- * Loads {@link AXPPropertyDefinition} instances on demand when not registered in {@link AXPPropertyRegistry}.
+ * Interface for schema loaders that can provide schemas on-demand
  */
-interface AXPPropertyLoader {
+interface AXPSchemaLoader {
     /**
      * Optional priority for loader ordering. Higher numbers = higher priority.
      * If not specified, uses registration order.
      */
     readonly priority?: number;
     /**
-     * Determines if this loader can handle the given registered property name.
+     * Determines if this loader can handle the given schema name
+     * @param schemaName The name of the schema to load
+     * @returns true if this loader can load the schema
      */
-    canLoad(propertyName: string): boolean;
+    canLoad(schemaName: string): boolean;
     /**
-     * Loads the property definition for the given name, or null if not found.
+     * Loads the schema definition for the given name
+     * @param schemaName The name of the schema to load
+     * @returns Promise that resolves to the schema definition or null if not found
      */
-    load(propertyName: string): Promise<AXPPropertyDefinition | null>;
+    load(schemaName: string): Promise<AXPSchemaDefinition | null>;
 }
 
 /**
@@ -866,13 +620,13 @@ interface AXPPropertyLoader {
  * }
  * ```
  */
-declare class AXPPropertyMiddlewareContext {
-    private _definition;
-    constructor(definition: AXPPropertyDefinition);
+declare class AXPSchemaMiddlewareContext {
+    private _schema;
+    constructor(schema: AXPSchemaDefinition);
     /**
      * Get the current schema definition (readonly access)
      */
-    get definition(): Readonly<AXPPropertyDefinition>;
+    get schema(): Readonly<AXPSchemaDefinition>;
     /**
      * Get the schema name for conditional logic
      */
@@ -881,7 +635,7 @@ declare class AXPPropertyMiddlewareContext {
      * Set a default value for the widget
      * @param defaultValue The default value to set
      */
-    withDefaultValue(defaultValue: unknown): this;
+    withDefaultValue(defaultValue: any): this;
     /**
      * Remove the default value from the widget
      */
@@ -914,7 +668,7 @@ declare class AXPPropertyMiddlewareContext {
      * Set or merge widget options
      * @param options Object containing widget-specific options to merge
      */
-    withWidgetOptions(options: Record<string, unknown>): this;
+    withWidgetOptions(options: any): this;
     /**
      * Remove a specific widget option by key
      * @param optionKey The key of the option to remove
@@ -957,6 +711,11 @@ declare class AXPPropertyMiddlewareContext {
      * @param key The metadata key to remove
      */
     removeMetadata(key: string): this;
+    /**
+     * Set the data type for this schema
+     * @param dataType The new data type (string, number, boolean, etc.)
+     */
+    withDataType(dataType: AXPSchemaDataType): this;
     /**
      * Set the disabled state of the widget
      * @param isDisabled Whether the widget should be disabled
@@ -975,16 +734,15 @@ declare class AXPPropertyMiddlewareContext {
 }
 
 /**
- * Middleware that can transform a property definition during resolution.
- *
- * @param context - Mutable {@link AXPPropertyMiddlewareContext} wrapping a cloned {@link AXPPropertyDefinition}.
+ * Middleware function that can transform schema definitions
+ * @param context - Schema middleware context providing schema info and configuration methods
  */
-type AXPPropertyMiddleware = (context: AXPPropertyMiddlewareContext) => void | Promise<void>;
+type AXPSchemaMiddleware = (context: AXPSchemaMiddlewareContext) => void | Promise<void>;
 
 /**
  * Options for registering a schema with additional metadata and middleware
  */
-interface AXPPropertyRegistrationOptions {
+interface AXPSchemaRegistrationOptions {
     /** Optional description for documentation purposes */
     description?: string;
     /** Tags for categorizing and finding schemas */
@@ -992,18 +750,18 @@ interface AXPPropertyRegistrationOptions {
     /** Version information for schema evolution */
     version?: string;
     /** Schema-specific middleware that applies only to this schema */
-    middleware?: AXPPropertyMiddleware[];
+    middleware?: AXPSchemaMiddleware[];
 }
 /**
  * Internal representation of a registered schema with metadata
  */
-interface AXPRegisteredProperty {
+interface AXPRegisteredSchema {
     /** Unique identifier for the schema */
     name: string;
     /** The actual schema definition */
-    definition: AXPPropertyDefinition;
+    definition: AXPSchemaDefinition;
     /** Registration options and metadata */
-    options: AXPPropertyRegistrationOptions;
+    options: AXPSchemaRegistrationOptions;
     /** Timestamp when the schema was registered */
     registeredAt: Date;
 }
@@ -1016,8 +774,8 @@ interface AXPRegisteredProperty {
  * - On-demand schema loading
  * - Caching and performance optimization
  */
-declare class AXPPropertyRegistry {
-    private readonly _registrations;
+declare class AXPSchemaRegistry {
+    private readonly _schemas;
     private readonly _globalMiddleware;
     private readonly _modelCache;
     private _loaders;
@@ -1025,14 +783,14 @@ declare class AXPPropertyRegistry {
     /**
      * Register a schema definition with optional metadata and middleware
      */
-    register(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): void;
+    register(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): void;
     /**
      * Register multiple schemas at once for batch operations
      */
-    registerBatch(entries: {
+    registerBatch(schemas: {
         name: string;
-        definition: AXPPropertyDefinition;
-        options?: AXPPropertyRegistrationOptions;
+        definition: AXPSchemaDefinition;
+        options?: AXPSchemaRegistrationOptions;
     }[]): void;
     /**
      * Remove a schema from the registry
@@ -1046,20 +804,20 @@ declare class AXPPropertyRegistry {
      * Resolve a schema by name with full middleware processing and caching.
      * Supports on-demand loading if schema is not registered.
      */
-    resolve(name: string): Promise<AXPPropertyModel>;
+    resolve(name: string): Promise<AXPSchemaModel>;
     /**
      * Synchronous resolution without middleware processing.
      * Use only when middleware is not needed for performance.
      */
-    resolveSync(name: string): AXPPropertyModel;
+    resolveSync(name: string): AXPSchemaModel;
     /**
      * Add global middleware that applies to all schema resolutions
      */
-    addGlobalMiddleware(middleware: AXPPropertyMiddleware): void;
+    addGlobalMiddleware(middleware: AXPSchemaMiddleware): void;
     /**
      * Remove specific global middleware
      */
-    removeGlobalMiddleware(middleware: AXPPropertyMiddleware): boolean;
+    removeGlobalMiddleware(middleware: AXPSchemaMiddleware): boolean;
     /**
      * Clear all global middleware
      */
@@ -1067,7 +825,7 @@ declare class AXPPropertyRegistry {
     /**
      * Add a schema loader for on-demand loading
      */
-    addLoader(loader: Type<AXPPropertyLoader>): void;
+    addLoader(loader: Type<AXPSchemaLoader>): void;
     /**
      * Get all registered schema names
      */
@@ -1075,29 +833,29 @@ declare class AXPPropertyRegistry {
     /**
      * Get detailed registration information for a schema
      */
-    getRegisteredProperty(name: string): AXPRegisteredProperty | undefined;
+    getSchemaInfo(name: string): AXPRegisteredSchema | undefined;
     /**
-     * Get all registered properties with their metadata
+     * Get all registered schemas with their metadata
      */
-    getAllRegisteredProperties(): AXPRegisteredProperty[];
+    getAllSchemas(): AXPRegisteredSchema[];
     /**
-     * Find registered properties by tag for categorization
+     * Find schemas by tag for categorization
      */
-    findByTag(tag: string): AXPRegisteredProperty[];
+    findByTag(tag: string): AXPRegisteredSchema[];
     /**
-     * Find registered properties by widget type for widget-specific operations
+     * Find schemas by widget type for widget-specific operations
      */
-    findByWidget(widgetType: string): AXPRegisteredProperty[];
+    findByWidget(widgetType: string): AXPRegisteredSchema[];
     /**
      * Get comprehensive registry statistics
      */
     getStatistics(): {
-        propertyCount: number;
+        schemaCount: number;
         globalMiddlewareCount: number;
-        propertiesByWidget: {
+        schemasByWidget: {
             [widget: string]: number;
         };
-        propertiesByTag: {
+        schemasByTag: {
             [tag: string]: number;
         };
     };
@@ -1125,123 +883,124 @@ declare class AXPPropertyRegistry {
      * Create a deep clone of a schema definition to prevent mutations
      */
     private cloneDefinition;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPropertyRegistry, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPropertyRegistry>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSchemaRegistry>;
 }
 
 /**
- * High-level facade for registered property definitions ({@link AXPPropertyDefinition}).
+ * High-level facade service for schema operations.
  *
- * Wraps {@link AXPPropertyRegistry} with convenience methods for resolution and discovery.
+ * Provides a simplified interface to the schema registry with additional
+ * business logic and convenience methods for common operations.
  */
-declare class AXPPropertyService {
+declare class AXPSchemaService {
     private readonly registry;
     /**
-     * Register a property definition with optional configuration
+     * Register a schema with optional configuration
      */
-    register(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): void;
+    register(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): void;
     /**
-     * Register multiple property definitions at once
+     * Register multiple schemas at once
      */
-    registerBatch(entries: {
+    registerBatch(schemas: {
         name: string;
-        definition: AXPPropertyDefinition;
-        options?: AXPPropertyRegistrationOptions;
+        definition: AXPSchemaDefinition;
+        options?: AXPSchemaRegistrationOptions;
     }[]): void;
     /**
-     * Remove a property definition from the registry
+     * Remove a schema from the registry
      */
     unregister(name: string): boolean;
     /**
-     * Check if a property definition is registered by name
+     * Check if a schema is registered
      */
     isRegistered(name: string): boolean;
     /**
-     * Get all registered property names
+     * Get all registered schema names
      */
     getRegisteredNames(): string[];
     /**
-     * Clear all registrations and reset the registry
+     * Clear all schemas and reset the registry
      */
     clear(): void;
     /**
-     * Resolve a registered property by name with full middleware processing
+     * Resolve a schema with full middleware processing
      */
-    resolve(name: string): Promise<AXPPropertyModel>;
+    resolve(name: string): Promise<AXPSchemaModel>;
     /**
-     * Resolve synchronously without middleware (for performance)
+     * Resolve schema synchronously without middleware (for performance)
      */
-    resolveSync(name: string): AXPPropertyModel;
+    resolveSync(name: string): AXPSchemaModel;
     /**
-     * Resolve multiple registered properties for form building and batch operations
+     * Resolve multiple schemas for form building and batch operations
      */
     resolveMultiple(fieldConfigs: {
         name: string;
-        propertyName: string;
+        schemaName: string;
     }[]): Promise<{
         name: string;
-        property: AXPPropertyModel;
+        schema: AXPSchemaModel;
     }[]>;
     /**
-     * Add global middleware that applies to all property resolutions
+     * Add global middleware that applies to all schema resolutions
      */
-    addGlobalMiddleware(middleware: AXPPropertyMiddleware): void;
+    addGlobalMiddleware(middleware: AXPSchemaMiddleware): void;
     /**
      * Remove specific global middleware
      */
-    removeGlobalMiddleware(middleware: AXPPropertyMiddleware): boolean;
+    removeGlobalMiddleware(middleware: AXPSchemaMiddleware): boolean;
     /**
      * Clear all global middleware
      */
     clearGlobalMiddleware(): void;
     /**
-     * Get detailed information about a registered property definition
+     * Get detailed information about a registered schema
      */
-    getRegisteredProperty(name: string): AXPRegisteredProperty | undefined;
+    getSchemaInfo(name: string): AXPRegisteredSchema | undefined;
     /**
-     * Get all registered property definitions with their metadata
+     * Get all registered schemas with their metadata
      */
-    getAllRegisteredProperties(): AXPRegisteredProperty[];
+    getAllSchemas(): AXPRegisteredSchema[];
     /**
-     * Find registered properties by tag for categorization and grouping
+     * Find schemas by tag for categorization and grouping
      */
-    findByTag(tag: string): AXPRegisteredProperty[];
+    findByTag(tag: string): AXPRegisteredSchema[];
     /**
-     * Find registered properties by widget type for widget-specific operations
+     * Find schemas by widget type for widget-specific operations
      */
-    findByWidget(widgetType: string): AXPRegisteredProperty[];
+    findByWidget(widgetType: string): AXPRegisteredSchema[];
     /**
      * Get comprehensive registry statistics and analytics
      */
     getStatistics(): {
         mostUsedWidgets: string[];
         mostUsedTags: string[];
-        propertyCount: number;
+        schemaCount: number;
         globalMiddlewareCount: number;
-        propertiesByWidget: {
+        schemasByWidget: {
             [widget: string]: number;
         };
-        propertiesByTag: {
+        schemasByTag: {
             [tag: string]: number;
         };
     };
     /**
-     * Validate that all referenced property names exist in the registry
+     * Validate that all referenced schemas exist in the registry
      */
-    validatePropertyReferences(propertyNames: string[]): {
+    validateSchemaReferences(schemaNames: string[]): {
         valid: boolean;
-        missingPropertyNames: string[];
+        missingSchemas: string[];
     };
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPropertyService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPropertyService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSchemaService>;
 }
 
 /**
  * Configuration for a schema loader with optional priority setting
  */
-interface AXPPropertyLoaderConfig {
+interface AXPSchemaLoaderConfig {
     /** The loader class to instantiate */
-    loader: Type<AXPPropertyLoader>;
+    loader: Type<AXPSchemaLoader>;
     /** Optional priority for loader ordering (higher = higher priority) */
     priority?: number;
 }
@@ -1261,28 +1020,28 @@ interface AXPPropertyLoaderConfig {
  * @example
  * ```typescript
  * // Simple loader registration
- * providePropertyLoaders([
+ * provideSchemaLoaders([
  *   HttpSchemaLoader,
  *   FileSystemSchemaLoader
  * ])
  *
  * // With priority configuration
- * providePropertyLoaders([
+ * provideSchemaLoaders([
  *   { loader: HttpSchemaLoader, priority: 10 },
  *   { loader: FileSystemSchemaLoader, priority: 5 }
  * ])
  * ```
  */
-declare function providePropertyLoaders(loaders: Array<Type<AXPPropertyLoader> | AXPPropertyLoaderConfig>): EnvironmentProviders;
+declare function provideSchemaLoaders(loaders: Array<Type<AXPSchemaLoader> | AXPSchemaLoaderConfig>): EnvironmentProviders;
 
 /**
  * Schema entry for registration containing definition and optional metadata
  */
-interface AXPPropertyEntry {
+interface AXPSchemaEntry {
     /** The schema definition to register */
-    definition: AXPPropertyDefinition;
+    definition: AXPSchemaDefinition;
     /** Optional registration options and metadata */
-    options?: AXPPropertyRegistrationOptions;
+    options?: AXPSchemaRegistrationOptions;
 }
 /**
  * Provide schema setups for registration during application bootstrap.
@@ -1295,7 +1054,7 @@ interface AXPPropertyEntry {
  *
  * @example
  * ```typescript
- * providePropertySetups([
+ * provideSchemaSetups([
  *   {
  *     definition: emailSchema,
  *     options: {
@@ -1310,7 +1069,7 @@ interface AXPPropertyEntry {
  * ])
  * ```
  */
-declare function providePropertySetups(entries: AXPPropertyEntry[]): EnvironmentProviders;
+declare function provideSchemaSetups(schemas: AXPSchemaEntry[]): EnvironmentProviders;
 /**
  * Convenience function to provide a single schema setup.
  *
@@ -1323,13 +1082,13 @@ declare function providePropertySetups(entries: AXPPropertyEntry[]): Environment
  *
  * @example
  * ```typescript
- * provideProperty(emailSchema, {
+ * provideSchema(emailSchema, {
  *   tags: ['user', 'contact'],
  *   description: 'User email field'
  * })
  * ```
  */
-declare function provideProperty(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): EnvironmentProviders;
+declare function provideSchema(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): EnvironmentProviders;
 /**
  * Provide schema setups from a factory function for dynamic registration.
  *
@@ -1341,7 +1100,7 @@ declare function provideProperty(definition: AXPPropertyDefinition, options?: AX
  *
  * @example
  * ```typescript
- * providePropertiesFromFactory(async () => {
+ * provideSchemasFromFactory(async () => {
  *   const config = await loadConfiguration();
  *   return config.schemas.map(schema => ({
  *     definition: schema,
@@ -1350,14 +1109,14 @@ declare function provideProperty(definition: AXPPropertyDefinition, options?: AX
  * })
  * ```
  */
-declare function providePropertiesFromFactory(factory: () => AXPPropertyEntry[] | Promise<AXPPropertyEntry[]>): EnvironmentProviders;
+declare function provideSchemasFromFactory(schemaFactory: () => AXPSchemaEntry[] | Promise<AXPSchemaEntry[]>): EnvironmentProviders;
 
 /**
  * Middleware entry for registration - can be either a simple function or targeted middleware
  */
-type AXPPropertyMiddlewareEntry = AXPPropertyMiddleware | {
+type AXPSchemaMiddlewareEntry = AXPSchemaMiddleware | {
     target: string | RegExp;
-    middleware: AXPPropertyMiddleware;
+    middleware: AXPSchemaMiddleware;
 };
 /**
  * Provide schema middleware for registration in the application.
@@ -1371,16 +1130,16 @@ type AXPPropertyMiddlewareEntry = AXPPropertyMiddleware | {
  * @example
  * ```typescript
  * // Global middleware
- * providePropertyMiddleware([
+ * provideSchemaMiddleware([
  *   (context) => {
- *     if (context.definition.dataType === 'string') {
+ *     if (context.schema.dataType === 'string') {
  *       context.searchable(true);
  *     }
  *   }
  * ])
  *
  * // Targeted middleware
- * providePropertyMiddleware([
+ * provideSchemaMiddleware([
  *   {
  *     target: /^user_/,
  *     middleware: (context) => context.withMetadata({ category: 'user' })
@@ -1388,32 +1147,44 @@ type AXPPropertyMiddlewareEntry = AXPPropertyMiddleware | {
  * ])
  * ```
  */
-declare function providePropertyMiddleware(middleware: AXPPropertyMiddlewareEntry[]): EnvironmentProviders;
+declare function provideSchemaMiddleware(middleware: AXPSchemaMiddlewareEntry[]): EnvironmentProviders;
 
 /**
- * Targeted middleware extension (name or regex) for property resolution.
+ * Injection token for schema-specific middleware extensions.
+ *
+ * Used for targeted middleware that applies only to schemas matching
+ * specific patterns (name or regex). This enables fine-grained control
+ * over which schemas receive which middleware.
  */
-declare const AXP_PROPERTY_EXTENSION: InjectionToken<{
+declare const AXP_SCHEMA_EXTENSION: InjectionToken<{
     target: string | RegExp;
-    middleware: AXPPropertyMiddleware;
+    middleware: AXPSchemaMiddleware;
 }>;
 /**
- * Bootstrap hook: register property definitions known at build time.
+ * Injection token for schema setup initialization.
+ *
+ * Used during application bootstrap to register schemas that are
+ * known at build time. Multiple providers can use this token to
+ * contribute schemas to the registry.
  */
-declare const AXP_PROPERTY_SETUP: InjectionToken<void>;
+declare const AXP_SCHEMA_SETUP: InjectionToken<void>;
 /**
- * Bootstrap hook: register global middleware for every property resolution.
+ * Injection token for schema middleware setup initialization.
+ *
+ * Used during application bootstrap to register global middleware
+ * that applies to all schema resolutions. This enables centralized
+ * schema processing logic.
  */
-declare const AXP_PROPERTY_MIDDLEWARE_SETUP: InjectionToken<void>;
+declare const AXP_SCHEMA_MIDDLEWARE_SETUP: InjectionToken<void>;
 /**
- * Bootstrap hook: register on-demand property loaders.
+ * Injection token for schema loader setup initialization.
+ *
+ * Used during application bootstrap to register schema loaders
+ * that can provide schemas on-demand when they're not found in
+ * the registry.
  */
-declare const AXP_PROPERTY_LOADER_SETUP: InjectionToken<void>;
+declare const AXP_SCHEMA_LOADER_SETUP: InjectionToken<void>;
 
-/**
- * Strips entity-only fields so the payload matches {@link AXPPropertyDefinition}.
- */
-declare function toPropertyDefinition(def: AXPEntityPropertyDefinition): AXPPropertyDefinition;
 /**
  * Runtime model for entity field definitions with parent references and helper methods
  */
@@ -1423,16 +1194,13 @@ declare class AXPEntityFieldModel {
     readonly description?: string;
     readonly validations?: AXPValidationRules;
     readonly actions?: AXPDomainAction[];
-    readonly fieldFeatures?: AXPEntityPropertyFeatures;
-    readonly defaultValue?: unknown;
-    /** Resolved property definition model (interface, validations, features). */
-    readonly property: AXPPropertyModel;
-    /** Same as entity field name; aligns with registered property definition name when applicable. */
-    readonly propertyName: string;
+    readonly features?: AXPEntityFieldFeatures;
+    readonly defaultValue?: any;
+    readonly schema: AXPSchemaModel;
+    readonly schemaName: string;
     readonly parent: any;
-    readonly propertyService: AXPPropertyService;
-    private readonly entityPropertyDefinition;
-    constructor(definition: AXPEntityPropertyDefinition, parent: any, propertyService: AXPPropertyService);
+    readonly schemaService: AXPSchemaService;
+    constructor(definition: AXPEntityFieldDefinition, parent: any, schemaService: AXPSchemaService);
     /**
      * Check if field is nullable
      */
@@ -1470,17 +1238,17 @@ declare class AXPEntityFieldModel {
      */
     isAuditable(): boolean;
     /**
-     * Registered property name (same as entity field name in the embedded model).
+     * Get the schema name
      */
-    getPropertyName(): string;
+    getSchemaName(): string;
     /**
-     * Registration metadata when this field's definition name is registered; otherwise embedded summary.
+     * Get schema info from registry
      */
-    getPropertyInfo(): unknown;
+    getSchemaInfo(): any;
     /**
-     * Rebuild the property model from embedded definition (e.g. after definition updates).
+     * Re-resolve schema from registry (useful after schema updates)
      */
-    refreshProperty(): void;
+    refreshSchema(): void;
     /**
      * Get parent entity
      */
@@ -1507,7 +1275,7 @@ declare class AXPEntityFieldModel {
     getStatistics(): {
         hasValidations: boolean;
         hasActions: boolean;
-        hasFieldFeatures: boolean;
+        hasFeatures: boolean;
         hasDefaultValue: boolean;
         validationCount: number;
         actionCount: number;
@@ -1527,7 +1295,7 @@ declare class AXPEntityFieldModel {
     /**
      * Convert back to interface definition
      */
-    toDefinition(): AXPEntityPropertyDefinition;
+    toDefinition(): AXPEntityFieldDefinition;
 }
 
 /**
@@ -1539,8 +1307,8 @@ declare class AXPEntityModel {
     readonly fields: AXPEntityFieldModel[];
     readonly type: AXPEntityType;
     readonly parent: any;
-    readonly propertyService: AXPPropertyService;
-    constructor(definition: AXPEntityDefinition, parent: any, propertyService: AXPPropertyService);
+    readonly schemaService: AXPSchemaService;
+    constructor(definition: AXPEntityDefinition, parent: any, schemaService: AXPSchemaService);
     /**
      * Find field by name
      */
@@ -1549,6 +1317,10 @@ declare class AXPEntityModel {
      * Get all fields
      */
     getAllFields(): AXPEntityFieldModel[];
+    /**
+     * Get fields by data type
+     */
+    getFieldsByType(dataType: string): AXPEntityFieldModel[];
     /**
      * Get required fields
      */
@@ -1614,110 +1386,6 @@ declare class AXPEntityModel {
     toDefinition(): AXPEntityDefinition;
 }
 
-/**
- * Runtime model for standalone relation definitions.
- * Relations live in their own collection; join when needed.
- */
-declare class AXPRelationModel {
-    readonly type: AXPRelationshipCardinality;
-    readonly kind: AXPRelationshipKind;
-    readonly target: {
-        aggregate: string;
-        entity: string;
-        key: string;
-    };
-    readonly source: {
-        aggregate: string;
-        entity: string;
-        key: string;
-    };
-    readonly isRequired: boolean;
-    readonly parent: any;
-    constructor(definition: AXPRelationDefinition, parent: any);
-    /**
-     * Check if relation is one-to-one
-     */
-    isOneToOne(): boolean;
-    /**
-     * Check if relation is one-to-many
-     */
-    isOneToMany(): boolean;
-    /**
-     * Check if relation is many-to-many
-     */
-    isManyToMany(): boolean;
-    /**
-     * Check if relation is association
-     */
-    isAssociation(): boolean;
-    /**
-     * Check if relation is composition
-     */
-    isComposition(): boolean;
-    /**
-     * Check if relation is aggregation
-     */
-    isAggregation(): boolean;
-    /**
-     * Get parent aggregate
-     */
-    getAggregate(): any;
-    /**
-     * Get parent module
-     */
-    getModule(): any;
-    /**
-     * Get full path (module.aggregate.relation)
-     */
-    getPath(): string;
-    /**
-     * Get relation description
-     */
-    getDescription(): string;
-    /**
-     * Get cardinality description
-     */
-    getCardinalityDescription(): string;
-    /**
-     * Get kind description
-     */
-    getKindDescription(): string;
-    /**
-     * Get relation summary
-     */
-    getSummary(): string;
-    /**
-     * Validate the relation structure
-     */
-    validate(): string[];
-    /**
-     * Get relation characteristics
-     */
-    getCharacteristics(): {
-        type: string;
-        kind: string;
-        required: boolean;
-        isOwning: boolean;
-        isNavigable: boolean;
-    };
-    /**
-     * Check if relation involves entity
-     */
-    involvesEntity(entityName: string): boolean;
-    /**
-     * Check if relation targets aggregate
-     */
-    targetsAggregate(aggregateName: string): boolean;
-    /**
-     * Get the other entity in the relation
-     */
-    getOtherEntity(entityName: string): string | null;
-    /**
-     * Convert back to interface definition (AXPRelationDefinition with full source/target)
-     */
-    toDefinition(): AXPRelationDefinition;
-}
-
 /**
  * Helper utility class for working with module models
  *
@@ -1760,9 +1428,9 @@ declare class AXPModuleHelper {
      */
     static findFieldsWithDefaultValues(module: AXPModuleModel): AXPEntityFieldModel[];
     /**
-     * @deprecated Use AXPDomainService with registered property name queries instead
+     * @deprecated Use AXPDomainService with field schema queries instead
      */
-    static findFieldsByRegisteredPropertyName(module: AXPModuleModel, propertyName: string): AXPEntityFieldModel[];
+    static findFieldsBySchema(module: AXPModuleModel, schemaName: string): AXPEntityFieldModel[];
     /**
      * @deprecated Use module.validate() method instead
      */
@@ -1907,7 +1575,7 @@ declare class AXPDomainRegistry {
     private readonly _aggregateMiddleware;
     private readonly _entityMiddleware;
     private _loaders;
-    private readonly propertyService;
+    private readonly schemaService;
     /**
      * Resolve a domain object by path with full middleware processing.
      * Supports definition-level caching with fresh model creation.
@@ -2375,5 +2043,5 @@ declare function provideDomainMiddleware(config: {
     entities?: AXPDomainMiddleware[];
 }): EnvironmentProviders;
 
-export { AXPAggregateModel, AXPDomainActionSide, AXPDomainMiddlewareContext, AXPDomainModule, AXPDomainRegistry, AXPDomainService, AXPEntityCommandScope, AXPEntityFieldModel, AXPEntityModel, AXPEntityType, AXPModuleHelper, AXPModuleModel, AXPPropertyMiddlewareContext, AXPPropertyModel, AXPPropertyRegistry, AXPPropertyService, AXPRelationModel, AXPRelationshipCardinality, AXPRelationshipKind, AXP_AGGREGATE_MIDDLEWARE_SETUP, AXP_ENTITY_CRUD_SETUP, AXP_ENTITY_DEFINITION_CRUD_SERVICE, AXP_ENTITY_MIDDLEWARE_SETUP, AXP_MODULE_MIDDLEWARE_SETUP, AXP_PROPERTY_EXTENSION, AXP_PROPERTY_LOADER_SETUP, AXP_PROPERTY_MIDDLEWARE_SETUP, AXP_PROPERTY_SETUP, provideAggregateMiddleware, provideDomainLoader, provideDomainLoaders, provideDomainMiddleware, provideEntityMiddleware, provideModuleMiddleware, providePropertiesFromFactory, provideProperty, providePropertyLoaders, providePropertyMiddleware, providePropertySetups, toPropertyDefinition };
-export type { AXPAggregateDefinition, AXPAggregateEntityList, AXPCommandCapability, AXPCommandRegistryRecord, AXPDomainAction, AXPDomainDefinition, AXPDomainLoader, AXPDomainLoaderConfig, AXPDomainMiddleware, AXPDomainPathInfo, AXPDomainRealtedModuleEntity, AXPEntityDefinition, AXPEntityDefinitionCrudService, AXPEntityPropertyDefinition, AXPEntityPropertyFeatures, AXPInterfaceCategory, AXPInterfaceDefinition, AXPInterfaceDefinitionValue, AXPMenuDefinitionEntityListRef, AXPMenuDefinitionRecord, AXPMenuDefinitionStoredCommand, AXPModuleDefinition, AXPPermissionDefinitionRecord, AXPPermissionGroupDefinitionRecord, AXPPermissionLeafRecord, AXPPluginDefinition, AXPPluginDefinitionValue, AXPPropertyDefinition, AXPPropertyEntry, AXPPropertyFeatures, AXPPropertyLoader, AXPPropertyLoaderConfig, AXPPropertyMiddleware, AXPPropertyMiddlewareEntry, AXPPropertyRegistrationOptions, AXPQueryRegistryRecord, AXPRegisteredProperty, AXPRelationDefinition, AXPValidationRuleDefinition, AXPValidationRuleValue, AXPValidationRunAt, AXPWidgetCatalogRecord };
+export { AXPAggregateModel, AXPDomainMiddlewareContext, AXPDomainModule, AXPDomainRegistry, AXPDomainService, AXPEntityCommandScope, AXPEntityFieldModel, AXPEntityModel, AXPEntityType, AXPModuleHelper, AXPModuleModel, AXPRelationModel, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaMiddlewareContext, AXPSchemaModel, AXPSchemaRegistry, AXPSchemaService, AXP_AGGREGATE_MIDDLEWARE_SETUP, AXP_ENTITY_CRUD_SETUP, AXP_ENTITY_MIDDLEWARE_SETUP, AXP_MODULE_MIDDLEWARE_SETUP, AXP_SCHEMA_EXTENSION, AXP_SCHEMA_LOADER_SETUP, AXP_SCHEMA_MIDDLEWARE_SETUP, AXP_SCHEMA_SETUP, provideAggregateMiddleware, provideDomainLoader, provideDomainLoaders, provideDomainMiddleware, provideEntity, provideEntityMiddleware, provideModuleMiddleware, provideSchema, provideSchemaLoaders, provideSchemaMiddleware, provideSchemaSetups, provideSchemasFromFactory };
+export type { AXPAggregateDefinition, AXPAggregateEntityList, AXPAggregateRelationDefinition, AXPDomainAction, AXPDomainDefinition, AXPDomainLoader, AXPDomainLoaderConfig, AXPDomainMiddleware, AXPDomainPathInfo, AXPEntityDefinition, AXPEntityFieldDefinition, AXPEntityFieldFeatures, AXPModuleDefinition, AXPRegisteredSchema, AXPSchemaDataType, AXPSchemaDefinition, AXPSchemaEntry, AXPSchemaFeatures, AXPSchemaInterface, AXPSchemaLoader, AXPSchemaLoaderConfig, AXPSchemaMiddleware, AXPSchemaMiddlewareEntry, AXPSchemaRegistrationOptions };