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

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

@@ -1,38 +1,20 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, EnvironmentProviders, Type } from '@angular/core';
+import { InjectionToken, Type, EnvironmentProviders } from '@angular/core';
+import { AXPExpression, AXPMetaData, AXPDataType, AXPOptionsData, AXPDefinitionCategory, AXPValidationRules } from '@acorex/platform/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 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>;
+declare enum AXPDomainActionSide {
+    Client = "client",
+    Server = "server",
+    Both = "both"
 }
-
 /**
  * Interface for defining actions
  */
@@ -48,31 +30,124 @@ 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;
+    };
+}
 
-declare enum AXPEntityType {
-    Entity = 0,
-    AggregateRoot = 1,
-    ValueObject = 2
+/**
+ * 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 AXPEntityDefinition {
+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;
-    fields: AXPEntityFieldDefinition[];
-    type: AXPEntityType;
+    description?: string;
+    icon?: string;
+    defaultValue?: unknown;
+    disabled?: boolean;
+    dataType?: AXPDataType;
+    interface: AXPInterfaceDefinitionValue;
+    validations?: AXPValidationRuleValue[];
+    features?: AXPPropertyFeatures;
+    metadata?: AXPMetaData;
 }
-interface AXPEntityFieldFeatures {
-    nullable: boolean;
-    readOnly: boolean;
+
+/** Widget category for interface grouping (e.g. Editors, Layout, Action). */
+interface AXPInterfaceCategory {
+    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[];
 }
-interface AXPEntityFieldDefinition {
+interface AXPInterfaceDefinitionValue {
+    name: string;
+    title: string;
+    options?: AXPOptionsData;
+}
+
+/**
+ * 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 {
     name: string;
     title: string;
     description?: string;
-    validations?: AXPValidationRules;
-    actions?: AXPDomainAction[];
-    features?: AXPEntityFieldFeatures;
-    defaultValue?: any;
-    schema: 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;
 }
 
 declare enum AXPRelationshipKind {
@@ -86,188 +161,409 @@ declare enum AXPRelationshipCardinality {
     ManyToMany = 2
 }
 /**
- * Interface for defining relationships between aggregates
+ * Standalone relation definition with full source and target.
+ * Relations live in their own collection, independent of aggregates.
  */
-interface AXPAggregateRelationDefinition {
+interface AXPRelationDefinition {
+    id?: string;
     type: AXPRelationshipCardinality;
     kind: AXPRelationshipKind;
-    target: {
+    source: {
         aggregate: string;
         entity: string;
         key: string;
     };
-    source: {
+    target: {
+        aggregate: string;
         entity: string;
         key: string;
     };
     isRequired: boolean;
 }
 
-type AXPAggregateEntityList = {
-    [key: string]: () => Promise<AXPEntityDefinition>;
+/**
+ * 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>;
 };
-interface AXPAggregateDefinition {
+/**
+ * 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;
-    title: string;
-    entities: AXPEntityDefinition[] | AXPAggregateEntityList | Record<string, string>;
-    relations: AXPAggregateRelationDefinition[];
-    validations: AXPValidationRules;
-    actions: AXPDomainAction[];
+    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>;
 }
 
-interface AXPModuleDefinition {
+/**
+ * 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;
-    aggregates: AXPAggregateDefinition[];
+    description?: string;
+    requiredFeatures?: string[];
+}
+/**
+ * Root permission row: one `addPermission` … `endPermission` chain, with optional sibling `addChild` entries.
+ */
+interface AXPPermissionDefinitionRecord {
+    name: string;
+    title: string;
+    description?: string;
+    requiredFeatures?: string[];
+    /** At most one level — matches `AXPPermissionDefinitionProviderContext` fluent API. */
+    children?: AXPPermissionLeafRecord[];
+}
+/**
+ * Serializable permission group for definition stores (Dexie/Firestore).
+ * Aligns with `AXPPermissionGroupDefinition` / fluent providers; one row per group.
+ */
+interface AXPPermissionGroupDefinitionRecord {
+    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;
+    }>;
 }
 
-type AXPSchemaDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'blob';
-interface AXPSchemaInterface {
-    widget: string;
-    options?: AXPOptionsData;
-    disabled?: boolean;
+/** 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[];
 }
-interface AXPSchemaFeatures {
-    searchable?: {
-        enabled: boolean;
-        fullText: boolean;
-    };
-    filterable?: {
-        enabled: boolean;
-        inline: boolean;
-    };
-    sortable?: {
-        enabled: boolean;
-    };
-    auditable?: {
-        enabled: 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 AXPSchemaDefinition {
+
+/**
+ * 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 {
     name: string;
-    dataType: AXPSchemaDataType;
-    interface: AXPSchemaInterface;
-    validations?: AXPValidationRules;
-    features?: AXPSchemaFeatures;
-    metadata?: AXPMetaData;
+    active: boolean;
+    description?: string;
+    /** Localized / catalog title from metadata `title`. */
+    catalogTitle?: string;
+    /** Pretty-printed JSON of full widget metadata (`defineWidget` sidecar). */
+    metadataJson?: string;
 }
 
 /**
- * Runtime model for relation definitions with parent references and helper methods
+ * 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).
  */
-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);
-    /**
-     * 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;
+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;
     /**
-     * Validate the relation structure
+     * Optional bootstrap hooks for registered property definitions (see {@link AXP_PROPERTY_SETUP} and related tokens).
      */
-    validate(): string[];
+    private _propertySetup;
+    private _propertyMiddlewareSetup;
+    private _propertyLoaderSetup;
     /**
-     * Get relation characteristics
+     * 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.
      */
-    getCharacteristics(): {
-        type: string;
-        kind: string;
-        required: boolean;
-        isOwning: boolean;
-        isNavigable: boolean;
+    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;
     };
-    /**
-     * 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;
+    /** 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[];
 }
 
 /**
  * Simple runtime model for aggregate definitions with parent references and navigation helpers.
- *
- * This model is a pure data structure that provides:
- * - Access to aggregate properties and metadata
- * - Navigation helpers for finding relations and entity references
- * - Parent module reference for hierarchy navigation
- *
- * All loading and resolution logic has been moved to AXPDomainRegistry.
+ * Relations are stored in a separate collection; join when needed.
  */
 declare class AXPAggregateModel {
     readonly name: string;
     readonly title: string;
-    readonly relations: AXPRelationModel[];
     readonly validations: AXPValidationRules;
     readonly actions: AXPDomainAction[];
     readonly parent: any;
@@ -305,21 +601,6 @@ 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
      *
@@ -339,7 +620,6 @@ declare class AXPAggregateModel {
      */
     getStatistics(): {
         entityCount: number;
-        relationCount: number;
         actionCount: number;
         validationCount: number;
     };
@@ -430,9 +710,8 @@ declare class AXPModuleModel {
      */
     getAllEntityReferences(): Record<string, string>;
     /**
-     * Get all relations across all aggregates
-     *
-     * @returns Array of all relation models
+     * Relations are stored in a separate collection. Use relation queries for join when needed.
+     * @deprecated Relations are no longer nested in aggregates.
      */
     getAllRelations(): Array<{
         aggregate: AXPAggregateModel;
@@ -452,7 +731,6 @@ declare class AXPModuleModel {
     getStatistics(): {
         aggregateCount: number;
         entityCount: number;
-        relationCount: number;
         actionCount: number;
         validationCount: number;
     };
@@ -465,54 +743,27 @@ declare class AXPModuleModel {
 }
 
 /**
- * Runtime model for schema definitions with helper methods
+ * Runtime model for a {@link AXPPropertyDefinition} with helper methods.
  */
-declare class AXPSchemaModel {
+declare class AXPPropertyModel {
     readonly name: string;
-    readonly dataType: AXPSchemaDataType;
-    readonly interface: AXPSchemaInterface;
+    readonly title: string;
+    readonly interface: AXPInterfaceDefinitionValue;
     readonly validations: AXPValidationRules;
-    readonly features: AXPSchemaFeatures;
+    readonly features: AXPPropertyFeatures;
     readonly metadata?: AXPMetaData;
-    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;
+    readonly description?: string;
+    readonly icon?: string;
+    readonly defaultValue?: unknown;
+    readonly disabled?: boolean;
+    readonly dataType: AXPDataType;
+    constructor(definition: AXPPropertyDefinition);
     /**
      * Get widget options
      */
     getWidgetOptions(): AXPOptionsData | undefined;
     /**
-     * Check if interface is disabled
+     * Check if the property is disabled
      */
     isDisabled(): boolean;
     /**
@@ -540,11 +791,11 @@ declare class AXPSchemaModel {
      */
     isAuditable(): boolean;
     /**
-     * Validate the schema structure
+     * Validate the property definition structure
      */
     validate(): Promise<string[]>;
     /**
-     * Get schema capabilities
+     * Get property capabilities
      */
     getCapabilities(): {
         searchable: boolean;
@@ -556,10 +807,9 @@ declare class AXPSchemaModel {
         disabled: boolean;
     };
     /**
-     * Get schema summary
+     * Get property summary
      */
     getSummary(): {
-        dataType: AXPSchemaDataType;
         widget: string;
         hasOptions: boolean;
         hasMetadata: boolean;
@@ -569,30 +819,26 @@ declare class AXPSchemaModel {
     /**
      * Convert back to interface definition
      */
-    toDefinition(): AXPSchemaDefinition;
+    toDefinition(): AXPPropertyDefinition;
 }
 
 /**
- * Interface for schema loaders that can provide schemas on-demand
+ * Loads {@link AXPPropertyDefinition} instances on demand when not registered in {@link AXPPropertyRegistry}.
  */
-interface AXPSchemaLoader {
+interface AXPPropertyLoader {
     /**
      * 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 schema name
-     * @param schemaName The name of the schema to load
-     * @returns true if this loader can load the schema
+     * Determines if this loader can handle the given registered property name.
      */
-    canLoad(schemaName: string): boolean;
+    canLoad(propertyName: string): boolean;
     /**
-     * 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
+     * Loads the property definition for the given name, or null if not found.
      */
-    load(schemaName: string): Promise<AXPSchemaDefinition | null>;
+    load(propertyName: string): Promise<AXPPropertyDefinition | null>;
 }
 
 /**
@@ -620,13 +866,13 @@ interface AXPSchemaLoader {
  * }
  * ```
  */
-declare class AXPSchemaMiddlewareContext {
-    private _schema;
-    constructor(schema: AXPSchemaDefinition);
+declare class AXPPropertyMiddlewareContext {
+    private _definition;
+    constructor(definition: AXPPropertyDefinition);
     /**
      * Get the current schema definition (readonly access)
      */
-    get schema(): Readonly<AXPSchemaDefinition>;
+    get definition(): Readonly<AXPPropertyDefinition>;
     /**
      * Get the schema name for conditional logic
      */
@@ -635,7 +881,7 @@ declare class AXPSchemaMiddlewareContext {
      * Set a default value for the widget
      * @param defaultValue The default value to set
      */
-    withDefaultValue(defaultValue: any): this;
+    withDefaultValue(defaultValue: unknown): this;
     /**
      * Remove the default value from the widget
      */
@@ -668,7 +914,7 @@ declare class AXPSchemaMiddlewareContext {
      * Set or merge widget options
      * @param options Object containing widget-specific options to merge
      */
-    withWidgetOptions(options: any): this;
+    withWidgetOptions(options: Record<string, unknown>): this;
     /**
      * Remove a specific widget option by key
      * @param optionKey The key of the option to remove
@@ -711,11 +957,6 @@ declare class AXPSchemaMiddlewareContext {
      * @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
@@ -734,15 +975,16 @@ declare class AXPSchemaMiddlewareContext {
 }
 
 /**
- * Middleware function that can transform schema definitions
- * @param context - Schema middleware context providing schema info and configuration methods
+ * Middleware that can transform a property definition during resolution.
+ *
+ * @param context - Mutable {@link AXPPropertyMiddlewareContext} wrapping a cloned {@link AXPPropertyDefinition}.
  */
-type AXPSchemaMiddleware = (context: AXPSchemaMiddlewareContext) => void | Promise<void>;
+type AXPPropertyMiddleware = (context: AXPPropertyMiddlewareContext) => void | Promise<void>;
 
 /**
  * Options for registering a schema with additional metadata and middleware
  */
-interface AXPSchemaRegistrationOptions {
+interface AXPPropertyRegistrationOptions {
     /** Optional description for documentation purposes */
     description?: string;
     /** Tags for categorizing and finding schemas */
@@ -750,18 +992,18 @@ interface AXPSchemaRegistrationOptions {
     /** Version information for schema evolution */
     version?: string;
     /** Schema-specific middleware that applies only to this schema */
-    middleware?: AXPSchemaMiddleware[];
+    middleware?: AXPPropertyMiddleware[];
 }
 /**
  * Internal representation of a registered schema with metadata
  */
-interface AXPRegisteredSchema {
+interface AXPRegisteredProperty {
     /** Unique identifier for the schema */
     name: string;
     /** The actual schema definition */
-    definition: AXPSchemaDefinition;
+    definition: AXPPropertyDefinition;
     /** Registration options and metadata */
-    options: AXPSchemaRegistrationOptions;
+    options: AXPPropertyRegistrationOptions;
     /** Timestamp when the schema was registered */
     registeredAt: Date;
 }
@@ -774,8 +1016,8 @@ interface AXPRegisteredSchema {
  * - On-demand schema loading
  * - Caching and performance optimization
  */
-declare class AXPSchemaRegistry {
-    private readonly _schemas;
+declare class AXPPropertyRegistry {
+    private readonly _registrations;
     private readonly _globalMiddleware;
     private readonly _modelCache;
     private _loaders;
@@ -783,14 +1025,14 @@ declare class AXPSchemaRegistry {
     /**
      * Register a schema definition with optional metadata and middleware
      */
-    register(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): void;
+    register(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): void;
     /**
      * Register multiple schemas at once for batch operations
      */
-    registerBatch(schemas: {
+    registerBatch(entries: {
         name: string;
-        definition: AXPSchemaDefinition;
-        options?: AXPSchemaRegistrationOptions;
+        definition: AXPPropertyDefinition;
+        options?: AXPPropertyRegistrationOptions;
     }[]): void;
     /**
      * Remove a schema from the registry
@@ -804,20 +1046,20 @@ declare class AXPSchemaRegistry {
      * Resolve a schema by name with full middleware processing and caching.
      * Supports on-demand loading if schema is not registered.
      */
-    resolve(name: string): Promise<AXPSchemaModel>;
+    resolve(name: string): Promise<AXPPropertyModel>;
     /**
      * Synchronous resolution without middleware processing.
      * Use only when middleware is not needed for performance.
      */
-    resolveSync(name: string): AXPSchemaModel;
+    resolveSync(name: string): AXPPropertyModel;
     /**
      * Add global middleware that applies to all schema resolutions
      */
-    addGlobalMiddleware(middleware: AXPSchemaMiddleware): void;
+    addGlobalMiddleware(middleware: AXPPropertyMiddleware): void;
     /**
      * Remove specific global middleware
      */
-    removeGlobalMiddleware(middleware: AXPSchemaMiddleware): boolean;
+    removeGlobalMiddleware(middleware: AXPPropertyMiddleware): boolean;
     /**
      * Clear all global middleware
      */
@@ -825,7 +1067,7 @@ declare class AXPSchemaRegistry {
     /**
      * Add a schema loader for on-demand loading
      */
-    addLoader(loader: Type<AXPSchemaLoader>): void;
+    addLoader(loader: Type<AXPPropertyLoader>): void;
     /**
      * Get all registered schema names
      */
@@ -833,29 +1075,29 @@ declare class AXPSchemaRegistry {
     /**
      * Get detailed registration information for a schema
      */
-    getSchemaInfo(name: string): AXPRegisteredSchema | undefined;
+    getRegisteredProperty(name: string): AXPRegisteredProperty | undefined;
     /**
-     * Get all registered schemas with their metadata
+     * Get all registered properties with their metadata
      */
-    getAllSchemas(): AXPRegisteredSchema[];
+    getAllRegisteredProperties(): AXPRegisteredProperty[];
     /**
-     * Find schemas by tag for categorization
+     * Find registered properties by tag for categorization
      */
-    findByTag(tag: string): AXPRegisteredSchema[];
+    findByTag(tag: string): AXPRegisteredProperty[];
     /**
-     * Find schemas by widget type for widget-specific operations
+     * Find registered properties by widget type for widget-specific operations
      */
-    findByWidget(widgetType: string): AXPRegisteredSchema[];
+    findByWidget(widgetType: string): AXPRegisteredProperty[];
     /**
      * Get comprehensive registry statistics
      */
     getStatistics(): {
-        schemaCount: number;
+        propertyCount: number;
         globalMiddlewareCount: number;
-        schemasByWidget: {
+        propertiesByWidget: {
             [widget: string]: number;
         };
-        schemasByTag: {
+        propertiesByTag: {
             [tag: string]: number;
         };
     };
@@ -883,124 +1125,123 @@ declare class AXPSchemaRegistry {
      * Create a deep clone of a schema definition to prevent mutations
      */
     private cloneDefinition;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaRegistry, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSchemaRegistry>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPropertyRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPropertyRegistry>;
 }
 
 /**
- * High-level facade service for schema operations.
+ * High-level facade for registered property definitions ({@link AXPPropertyDefinition}).
  *
- * Provides a simplified interface to the schema registry with additional
- * business logic and convenience methods for common operations.
+ * Wraps {@link AXPPropertyRegistry} with convenience methods for resolution and discovery.
  */
-declare class AXPSchemaService {
+declare class AXPPropertyService {
     private readonly registry;
     /**
-     * Register a schema with optional configuration
+     * Register a property definition with optional configuration
      */
-    register(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): void;
+    register(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): void;
     /**
-     * Register multiple schemas at once
+     * Register multiple property definitions at once
      */
-    registerBatch(schemas: {
+    registerBatch(entries: {
         name: string;
-        definition: AXPSchemaDefinition;
-        options?: AXPSchemaRegistrationOptions;
+        definition: AXPPropertyDefinition;
+        options?: AXPPropertyRegistrationOptions;
     }[]): void;
     /**
-     * Remove a schema from the registry
+     * Remove a property definition from the registry
      */
     unregister(name: string): boolean;
     /**
-     * Check if a schema is registered
+     * Check if a property definition is registered by name
      */
     isRegistered(name: string): boolean;
     /**
-     * Get all registered schema names
+     * Get all registered property names
      */
     getRegisteredNames(): string[];
     /**
-     * Clear all schemas and reset the registry
+     * Clear all registrations and reset the registry
      */
     clear(): void;
     /**
-     * Resolve a schema with full middleware processing
+     * Resolve a registered property by name with full middleware processing
      */
-    resolve(name: string): Promise<AXPSchemaModel>;
+    resolve(name: string): Promise<AXPPropertyModel>;
     /**
-     * Resolve schema synchronously without middleware (for performance)
+     * Resolve synchronously without middleware (for performance)
      */
-    resolveSync(name: string): AXPSchemaModel;
+    resolveSync(name: string): AXPPropertyModel;
     /**
-     * Resolve multiple schemas for form building and batch operations
+     * Resolve multiple registered properties for form building and batch operations
      */
     resolveMultiple(fieldConfigs: {
         name: string;
-        schemaName: string;
+        propertyName: string;
     }[]): Promise<{
         name: string;
-        schema: AXPSchemaModel;
+        property: AXPPropertyModel;
     }[]>;
     /**
-     * Add global middleware that applies to all schema resolutions
+     * Add global middleware that applies to all property resolutions
      */
-    addGlobalMiddleware(middleware: AXPSchemaMiddleware): void;
+    addGlobalMiddleware(middleware: AXPPropertyMiddleware): void;
     /**
      * Remove specific global middleware
      */
-    removeGlobalMiddleware(middleware: AXPSchemaMiddleware): boolean;
+    removeGlobalMiddleware(middleware: AXPPropertyMiddleware): boolean;
     /**
      * Clear all global middleware
      */
     clearGlobalMiddleware(): void;
     /**
-     * Get detailed information about a registered schema
+     * Get detailed information about a registered property definition
      */
-    getSchemaInfo(name: string): AXPRegisteredSchema | undefined;
+    getRegisteredProperty(name: string): AXPRegisteredProperty | undefined;
     /**
-     * Get all registered schemas with their metadata
+     * Get all registered property definitions with their metadata
      */
-    getAllSchemas(): AXPRegisteredSchema[];
+    getAllRegisteredProperties(): AXPRegisteredProperty[];
     /**
-     * Find schemas by tag for categorization and grouping
+     * Find registered properties by tag for categorization and grouping
      */
-    findByTag(tag: string): AXPRegisteredSchema[];
+    findByTag(tag: string): AXPRegisteredProperty[];
     /**
-     * Find schemas by widget type for widget-specific operations
+     * Find registered properties by widget type for widget-specific operations
      */
-    findByWidget(widgetType: string): AXPRegisteredSchema[];
+    findByWidget(widgetType: string): AXPRegisteredProperty[];
     /**
      * Get comprehensive registry statistics and analytics
      */
     getStatistics(): {
         mostUsedWidgets: string[];
         mostUsedTags: string[];
-        schemaCount: number;
+        propertyCount: number;
         globalMiddlewareCount: number;
-        schemasByWidget: {
+        propertiesByWidget: {
             [widget: string]: number;
         };
-        schemasByTag: {
+        propertiesByTag: {
             [tag: string]: number;
         };
     };
     /**
-     * Validate that all referenced schemas exist in the registry
+     * Validate that all referenced property names exist in the registry
      */
-    validateSchemaReferences(schemaNames: string[]): {
+    validatePropertyReferences(propertyNames: string[]): {
         valid: boolean;
-        missingSchemas: string[];
+        missingPropertyNames: string[];
     };
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSchemaService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPropertyService>;
 }
 
 /**
  * Configuration for a schema loader with optional priority setting
  */
-interface AXPSchemaLoaderConfig {
+interface AXPPropertyLoaderConfig {
     /** The loader class to instantiate */
-    loader: Type<AXPSchemaLoader>;
+    loader: Type<AXPPropertyLoader>;
     /** Optional priority for loader ordering (higher = higher priority) */
     priority?: number;
 }
@@ -1020,28 +1261,28 @@ interface AXPSchemaLoaderConfig {
  * @example
  * ```typescript
  * // Simple loader registration
- * provideSchemaLoaders([
+ * providePropertyLoaders([
  *   HttpSchemaLoader,
  *   FileSystemSchemaLoader
  * ])
  *
  * // With priority configuration
- * provideSchemaLoaders([
+ * providePropertyLoaders([
  *   { loader: HttpSchemaLoader, priority: 10 },
  *   { loader: FileSystemSchemaLoader, priority: 5 }
  * ])
  * ```
  */
-declare function provideSchemaLoaders(loaders: Array<Type<AXPSchemaLoader> | AXPSchemaLoaderConfig>): EnvironmentProviders;
+declare function providePropertyLoaders(loaders: Array<Type<AXPPropertyLoader> | AXPPropertyLoaderConfig>): EnvironmentProviders;
 
 /**
  * Schema entry for registration containing definition and optional metadata
  */
-interface AXPSchemaEntry {
+interface AXPPropertyEntry {
     /** The schema definition to register */
-    definition: AXPSchemaDefinition;
+    definition: AXPPropertyDefinition;
     /** Optional registration options and metadata */
-    options?: AXPSchemaRegistrationOptions;
+    options?: AXPPropertyRegistrationOptions;
 }
 /**
  * Provide schema setups for registration during application bootstrap.
@@ -1054,7 +1295,7 @@ interface AXPSchemaEntry {
  *
  * @example
  * ```typescript
- * provideSchemaSetups([
+ * providePropertySetups([
  *   {
  *     definition: emailSchema,
  *     options: {
@@ -1069,7 +1310,7 @@ interface AXPSchemaEntry {
  * ])
  * ```
  */
-declare function provideSchemaSetups(schemas: AXPSchemaEntry[]): EnvironmentProviders;
+declare function providePropertySetups(entries: AXPPropertyEntry[]): EnvironmentProviders;
 /**
  * Convenience function to provide a single schema setup.
  *
@@ -1082,13 +1323,13 @@ declare function provideSchemaSetups(schemas: AXPSchemaEntry[]): EnvironmentProv
  *
  * @example
  * ```typescript
- * provideSchema(emailSchema, {
+ * provideProperty(emailSchema, {
  *   tags: ['user', 'contact'],
  *   description: 'User email field'
  * })
  * ```
  */
-declare function provideSchema(definition: AXPSchemaDefinition, options?: AXPSchemaRegistrationOptions): EnvironmentProviders;
+declare function provideProperty(definition: AXPPropertyDefinition, options?: AXPPropertyRegistrationOptions): EnvironmentProviders;
 /**
  * Provide schema setups from a factory function for dynamic registration.
  *
@@ -1100,7 +1341,7 @@ declare function provideSchema(definition: AXPSchemaDefinition, options?: AXPSch
  *
  * @example
  * ```typescript
- * provideSchemasFromFactory(async () => {
+ * providePropertiesFromFactory(async () => {
  *   const config = await loadConfiguration();
  *   return config.schemas.map(schema => ({
  *     definition: schema,
@@ -1109,14 +1350,14 @@ declare function provideSchema(definition: AXPSchemaDefinition, options?: AXPSch
  * })
  * ```
  */
-declare function provideSchemasFromFactory(schemaFactory: () => AXPSchemaEntry[] | Promise<AXPSchemaEntry[]>): EnvironmentProviders;
+declare function providePropertiesFromFactory(factory: () => AXPPropertyEntry[] | Promise<AXPPropertyEntry[]>): EnvironmentProviders;
 
 /**
  * Middleware entry for registration - can be either a simple function or targeted middleware
  */
-type AXPSchemaMiddlewareEntry = AXPSchemaMiddleware | {
+type AXPPropertyMiddlewareEntry = AXPPropertyMiddleware | {
     target: string | RegExp;
-    middleware: AXPSchemaMiddleware;
+    middleware: AXPPropertyMiddleware;
 };
 /**
  * Provide schema middleware for registration in the application.
@@ -1130,16 +1371,16 @@ type AXPSchemaMiddlewareEntry = AXPSchemaMiddleware | {
  * @example
  * ```typescript
  * // Global middleware
- * provideSchemaMiddleware([
+ * providePropertyMiddleware([
  *   (context) => {
- *     if (context.schema.dataType === 'string') {
+ *     if (context.definition.dataType === 'string') {
  *       context.searchable(true);
  *     }
  *   }
  * ])
  *
  * // Targeted middleware
- * provideSchemaMiddleware([
+ * providePropertyMiddleware([
  *   {
  *     target: /^user_/,
  *     middleware: (context) => context.withMetadata({ category: 'user' })
@@ -1147,44 +1388,32 @@ type AXPSchemaMiddlewareEntry = AXPSchemaMiddleware | {
  * ])
  * ```
  */
-declare function provideSchemaMiddleware(middleware: AXPSchemaMiddlewareEntry[]): EnvironmentProviders;
+declare function providePropertyMiddleware(middleware: AXPPropertyMiddlewareEntry[]): EnvironmentProviders;
 
 /**
- * Injection token for schema-specific middleware extensions.
- *
- * Used for targeted middleware that applies only to schemas matching
- * specific patterns (name or regex). This enables fine-grained control
- * over which schemas receive which middleware.
+ * Targeted middleware extension (name or regex) for property resolution.
  */
-declare const AXP_SCHEMA_EXTENSION: InjectionToken<{
+declare const AXP_PROPERTY_EXTENSION: InjectionToken<{
     target: string | RegExp;
-    middleware: AXPSchemaMiddleware;
+    middleware: AXPPropertyMiddleware;
 }>;
 /**
- * Injection token for schema setup initialization.
- *
- * Used during application bootstrap to register schemas that are
- * known at build time. Multiple providers can use this token to
- * contribute schemas to the registry.
+ * Bootstrap hook: register property definitions known at build time.
  */
-declare const AXP_SCHEMA_SETUP: InjectionToken<void>;
+declare const AXP_PROPERTY_SETUP: InjectionToken<void>;
 /**
- * Injection token for schema middleware setup initialization.
- *
- * Used during application bootstrap to register global middleware
- * that applies to all schema resolutions. This enables centralized
- * schema processing logic.
+ * Bootstrap hook: register global middleware for every property resolution.
  */
-declare const AXP_SCHEMA_MIDDLEWARE_SETUP: InjectionToken<void>;
+declare const AXP_PROPERTY_MIDDLEWARE_SETUP: InjectionToken<void>;
 /**
- * Injection token for schema loader setup initialization.
- *
- * Used during application bootstrap to register schema loaders
- * that can provide schemas on-demand when they're not found in
- * the registry.
+ * Bootstrap hook: register on-demand property loaders.
  */
-declare const AXP_SCHEMA_LOADER_SETUP: InjectionToken<void>;
+declare const AXP_PROPERTY_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
  */
@@ -1194,13 +1423,16 @@ declare class AXPEntityFieldModel {
     readonly description?: string;
     readonly validations?: AXPValidationRules;
     readonly actions?: AXPDomainAction[];
-    readonly features?: AXPEntityFieldFeatures;
-    readonly defaultValue?: any;
-    readonly schema: AXPSchemaModel;
-    readonly schemaName: string;
+    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 parent: any;
-    readonly schemaService: AXPSchemaService;
-    constructor(definition: AXPEntityFieldDefinition, parent: any, schemaService: AXPSchemaService);
+    readonly propertyService: AXPPropertyService;
+    private readonly entityPropertyDefinition;
+    constructor(definition: AXPEntityPropertyDefinition, parent: any, propertyService: AXPPropertyService);
     /**
      * Check if field is nullable
      */
@@ -1238,17 +1470,17 @@ declare class AXPEntityFieldModel {
      */
     isAuditable(): boolean;
     /**
-     * Get the schema name
+     * Registered property name (same as entity field name in the embedded model).
      */
-    getSchemaName(): string;
+    getPropertyName(): string;
     /**
-     * Get schema info from registry
+     * Registration metadata when this field's definition name is registered; otherwise embedded summary.
      */
-    getSchemaInfo(): any;
+    getPropertyInfo(): unknown;
     /**
-     * Re-resolve schema from registry (useful after schema updates)
+     * Rebuild the property model from embedded definition (e.g. after definition updates).
      */
-    refreshSchema(): void;
+    refreshProperty(): void;
     /**
      * Get parent entity
      */
@@ -1275,7 +1507,7 @@ declare class AXPEntityFieldModel {
     getStatistics(): {
         hasValidations: boolean;
         hasActions: boolean;
-        hasFeatures: boolean;
+        hasFieldFeatures: boolean;
         hasDefaultValue: boolean;
         validationCount: number;
         actionCount: number;
@@ -1295,7 +1527,7 @@ declare class AXPEntityFieldModel {
     /**
      * Convert back to interface definition
      */
-    toDefinition(): AXPEntityFieldDefinition;
+    toDefinition(): AXPEntityPropertyDefinition;
 }
 
 /**
@@ -1307,8 +1539,8 @@ declare class AXPEntityModel {
     readonly fields: AXPEntityFieldModel[];
     readonly type: AXPEntityType;
     readonly parent: any;
-    readonly schemaService: AXPSchemaService;
-    constructor(definition: AXPEntityDefinition, parent: any, schemaService: AXPSchemaService);
+    readonly propertyService: AXPPropertyService;
+    constructor(definition: AXPEntityDefinition, parent: any, propertyService: AXPPropertyService);
     /**
      * Find field by name
      */
@@ -1317,10 +1549,6 @@ declare class AXPEntityModel {
      * Get all fields
      */
     getAllFields(): AXPEntityFieldModel[];
-    /**
-     * Get fields by data type
-     */
-    getFieldsByType(dataType: string): AXPEntityFieldModel[];
     /**
      * Get required fields
      */
@@ -1386,6 +1614,110 @@ 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
  *
@@ -1428,9 +1760,9 @@ declare class AXPModuleHelper {
      */
     static findFieldsWithDefaultValues(module: AXPModuleModel): AXPEntityFieldModel[];
     /**
-     * @deprecated Use AXPDomainService with field schema queries instead
+     * @deprecated Use AXPDomainService with registered property name queries instead
      */
-    static findFieldsBySchema(module: AXPModuleModel, schemaName: string): AXPEntityFieldModel[];
+    static findFieldsByRegisteredPropertyName(module: AXPModuleModel, propertyName: string): AXPEntityFieldModel[];
     /**
      * @deprecated Use module.validate() method instead
      */
@@ -1575,7 +1907,7 @@ declare class AXPDomainRegistry {
     private readonly _aggregateMiddleware;
     private readonly _entityMiddleware;
     private _loaders;
-    private readonly schemaService;
+    private readonly propertyService;
     /**
      * Resolve a domain object by path with full middleware processing.
      * Supports definition-level caching with fresh model creation.
@@ -2043,5 +2375,5 @@ declare function provideDomainMiddleware(config: {
     entities?: AXPDomainMiddleware[];
 }): EnvironmentProviders;
 
-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 };
+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 };