@acorex/platform 21.0.0-next.75 → 21.0.0-next.76

package/types/acorex-platform-contracts.d.ts

@@ -1,5 +1,1229 @@
-import { AXPProperty, AXPOptionsData, AXPMetaData, AXPEntityOp, AXPMultiLanguageString, AXPCategoryEntity } from '@acorex/platform/core';
-import { AXPWidgetNode } from '@acorex/platform/layout/widget-core';
+type AXDataSourceOperatorType = 'endsWith' | 'startsWith' | 'in' | 'equal' | 'isNull' | 'isEmpty' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains';
+interface AXDataSourceOperator {
+    type: AXDataSourceOperatorType;
+    negative?: boolean;
+}
+type AXStyleColorType = string;
+type AXPopupSizeType = string;
+type AXFilterLogic = 'and' | 'or';
+interface AXDataSourceFilterOption {
+    field?: string;
+    operator?: AXDataSourceOperator;
+    value?: unknown;
+    logic?: AXFilterLogic;
+    filters?: AXDataSourceFilterOption[];
+}
+
+/**
+ * Plain or rich text that may be localized: a single string or a map of locale code to string.
+ */
+type AXPMultiLanguageString = string | Record<string, string>;
+type AXPExpression = string;
+type AXPMetaData = Record<string, unknown>;
+type AXPOptionsData<T extends Record<string, unknown> = Record<string, any>> = T;
+interface AXPEntityReference {
+    id: string;
+    type: string;
+    title?: string;
+    metadata?: AXPMetaData;
+}
+interface AXPUserReference {
+    id: string;
+    type?: 'user';
+    fullName?: string;
+    username?: string;
+}
+type AXPContentType = 'text' | 'image' | 'file' | 'video' | 'link';
+interface AXPContent {
+    content: string;
+    contentType: AXPContentType;
+}
+type AXPFileStatus = 'attached' | 'uploading' | 'uploaded' | 'deleted' | 'remote' | 'editing';
+interface AXPFileSource {
+    kind: 'blob' | 'url' | 'preview' | 'none' | 'fileId' | 'reference';
+    value?: Blob | string | {
+        id: string;
+        type: string;
+        title?: string;
+        metadata?: AXPMetaData;
+    };
+}
+interface AXPFileListItem {
+    id?: string;
+    name: string;
+    size?: number;
+    status: AXPFileStatus;
+    source?: AXPFileSource;
+    meta?: AXPMetaData;
+    readOnly?: boolean;
+    title?: string;
+    description?: string;
+}
+type AXPDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'blob';
+type AXPWidgetTrigger = {
+    event: string;
+    action: string | string[];
+    disabled?: boolean;
+};
+type AXPWidgetTriggers = AXPWidgetTrigger[];
+type AXPValidationRule = {
+    rule: string;
+    message?: string;
+    options?: unknown;
+    disabled?: boolean | AXPExpression;
+};
+type AXPValidationRules = AXPValidationRule[];
+interface AXPGridPlacement {
+    colStart?: number;
+    colEnd?: number;
+    colSpan?: number;
+    rowStart?: number;
+    rowEnd?: number;
+    rowSpan?: number;
+    order?: string | number;
+}
+interface AXPGridLayoutOptions {
+    positions?: {
+        sm?: AXPGridPlacement;
+        md?: AXPGridPlacement;
+        lg?: AXPGridPlacement;
+        xl?: AXPGridPlacement;
+        xxl?: AXPGridPlacement;
+        xxxl?: AXPGridPlacement;
+    };
+}
+type AXPValueTransformerFunction = (value: unknown) => unknown;
+type AXPValueTransformerFunctions = {
+    getter?: AXPValueTransformerFunction;
+    setter?: AXPValueTransformerFunction;
+};
+declare enum AXPSystemActionType {
+    View = "view",
+    Create = "create",
+    Update = "update",
+    Delete = "delete",
+    Approve = "approve",
+    Reject = "reject",
+    Submit = "submit",
+    Export = "export",
+    Import = "import",
+    Print = "print",
+    Assign = "assign",
+    Lock = "lock",
+    Unlock = "unlock",
+    Share = "share",
+    Configure = "configure",
+    Reorder = "reorder",
+    Preview = "preview",
+    Duplicate = "duplicate",
+    Archive = "archive",
+    Publish = "publish",
+    Unpublish = "unpublish",
+    Upload = "upload",
+    Download = "download",
+    Copy = "copy",
+    Move = "move",
+    Rename = "rename",
+    Restore = "restore",
+    Manage = "manage",
+    Info = "info",
+    Confirm = "confirm",
+    Design = "design",
+    VersionHistory = "version-history",
+    Compare = "compare",
+    Comments = "comments",
+    Sign = "sign",
+    Setup = "setup",
+    Send = "send",
+    Report = "report",
+    Sent = "sent",
+    Review = "review",
+    Generate = "generate",
+    Refresh = "refresh",
+    Reload = "reload",
+    Search = "search",
+    Filter = "filter",
+    Sort = "sort",
+    Start = "start",
+    Stop = "stop",
+    Pause = "pause",
+    Cancel = "cancel",
+    Close = "close",
+    Complete = "complete",
+    Save = "save",
+    SaveAs = "save-as",
+    Sync = "sync",
+    Reset = "reset",
+    Clear = "clear",
+    Distribution = "distribution"
+}
+
+/**
+ * Builds a locale map for mock seed data (`en-US` + `fa-IR`).
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+declare function createMultiLanguageString(enUS: string, faIR?: string): Record<string, string>;
+/**
+ * Resolves {@link AXPMultiLanguageString} to a plain string for the given locale.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+declare function resolveMultiLanguageString(value: AXPMultiLanguageString | null | undefined, locale: string): string;
+/**
+ * Lightweight data helpers for mock seed files.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/platform/core.
+ */
+declare class AXPDataGenerator {
+    static uuid(): string;
+    static number(max: number): number;
+    static number(min: number, max: number): number;
+    static date(): Date;
+    static date(start: Date): Date;
+    static date(start: Date, end: Date): Date;
+    static array<T>(length: number | undefined, generator: () => T): T[];
+    static pick<T>(items: T[]): T;
+    static pick<T>(items: T[], count: number): T[];
+    static string(length?: number): string;
+    static boolean(): boolean;
+    static item<T>(array?: T[]): T | undefined;
+    static color(format?: 'hsl' | 'rgb' | 'hex'): string;
+    private static hslToRgb;
+    static alphanumeric(length?: number): string;
+    static alphabet(length?: number): string;
+    static phone(): string;
+    static firstName(): string;
+    static lastName(): string;
+    static email(): string;
+    static email(firstName: string, lastName: string): string;
+    static country(): string;
+    static city(): string;
+    static state(): string;
+    static address(): string;
+    static avatar(): string;
+}
+
+interface AXPCategoryEntity<TKey = string> {
+    id: TKey;
+    title: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    parentId?: TKey;
+    childrenCount: number;
+    itemsCount?: number;
+    totalChildrenCount?: number;
+    totalItemsCount?: number;
+}
+interface AXPCategoryListItem<TKey extends string = string> {
+    id: TKey;
+    title: AXPMultiLanguageString;
+}
+interface AXPCategoryEntityWithItems<T> extends AXPCategoryEntity {
+    items: T[];
+    children?: AXPCategoryEntityWithItems<T>[];
+}
+interface AXPCategorizedEntity {
+    categoryIds: string[];
+}
+interface AXPCategorizedEntityDto {
+    categoryIds: string[];
+    categories: AXPCategoryListItem[];
+}
+type AXPEntityOp = 'initial' | 'create' | 'update' | 'delete' | 'getOne' | 'getAll' | 'query' | 'count' | 'queryAll' | 'getMany' | 'exists' | 'upsertOne' | 'aggregate';
+
+interface AXPPropertyGroup {
+    name: string;
+    title: AXPMultiLanguageString;
+    icon?: string;
+    description?: AXPMultiLanguageString;
+    order?: number;
+}
+interface AXPPropertyInterface {
+    type: string;
+    options: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+}
+interface AXPProperty {
+    name: string;
+    title: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    dataType: AXPDataType;
+    validations?: AXPValidationRules;
+    group?: AXPPropertyGroup | string;
+    order?: number;
+    interface: AXPPropertyInterface;
+}
+
+interface AXPFilterTriggerDefinition {
+    event: string;
+    action: string;
+    disabled?: boolean;
+}
+interface AXPFilterClause extends AXDataSourceFilterOption {
+    id?: string;
+    order?: number;
+    filters?: AXPFilterClause[];
+}
+interface AXPFilterDefinition extends AXPFilterClause {
+    title: string;
+    isParametric?: boolean;
+    icon?: string;
+    widget: {
+        type: string;
+        options?: AXPOptionsData;
+    };
+    filterType: {
+        advance: boolean;
+        inline: boolean;
+        preload?: {
+            enabled?: boolean;
+            required?: boolean;
+        };
+    };
+    hidden?: boolean;
+    /**
+     * When true, the filter is not selectable. When a string, it is evaluated as an expression (e.g. `{{ ... }}`)
+     * using the current filters context.
+     */
+    disabled?: boolean | string;
+    /** Expression-driven triggers (events/actions); same semantics as entity `schema.interface.triggers`. */
+    triggers?: AXPFilterTriggerDefinition[];
+}
+interface AXPFilterQuery extends Pick<AXPFilterDefinition, 'field' | 'value' | 'operator' | 'logic' | 'hidden'> {
+    filters?: AXPFilterQuery[];
+    displayText?: string;
+}
+
+interface AXPAuditEvent {
+    at?: Date;
+    by?: AXPUserReference;
+    reason?: string;
+    source?: string;
+}
+interface AXPRecordAuditInfo {
+    created?: AXPAuditEvent;
+    updated?: AXPAuditEvent;
+    deleted?: AXPAuditEvent;
+}
+interface AXPRecordStateInfo {
+    isHidden?: boolean;
+    isSystem?: boolean;
+    isImmutable?: boolean;
+    /** @deprecated Prefer explicit domain modeling over this flag. */
+    isDistributed?: boolean;
+}
+interface AXPRecordOwnershipInfo {
+    tenantId?: string;
+    applicationId?: string;
+    userId?: string;
+}
+interface AXPRecordWorkflowInfo {
+    instanceId?: string | null;
+    definitionId?: string | null;
+    correlationId?: string | null;
+    pinnedVersion?: number | null;
+}
+interface AXPEntityModel<Id> {
+    id: Id;
+    auditInfo?: AXPRecordAuditInfo;
+    stateInfo?: AXPRecordStateInfo;
+    ownershipInfo?: AXPRecordOwnershipInfo;
+    workflowInfo?: AXPRecordWorkflowInfo;
+}
+interface AXPEntityCreateDto {
+}
+interface AXPEntityUpdateDto<Id> {
+    id: Id;
+}
+interface AXPEntityOutputDto<Id> {
+    id: Id;
+}
+interface AXPEntityDetailDto<Id> extends AXPEntityOutputDto<Id> {
+}
+interface AXPEntityListItemDto<Id> extends AXPEntityOutputDto<Id> {
+}
+interface AXPMockDto<Id> extends AXPEntityModel<Id> {
+}
+
+interface AXEntityPropertyWidget {
+    type: string;
+    path?: string;
+    id?: string;
+    children?: AXEntityPropertyWidget[];
+    mode: 'view' | 'edit';
+    options?: Record<string, any>;
+    triggers?: {
+        event: string;
+        action: string;
+        disabled?: boolean;
+    }[];
+    valueTransforms?: AXPValueTransformerFunctions;
+}
+declare enum AXPRelationshipKind {
+    Association = 0,
+    Composition = 1,
+    Aggregation = 2
+}
+declare enum AXPRelationshipCardinality {
+    OneToOne = 0,
+    OneToMany = 1,
+    ManyToMany = 2
+}
+interface AXPRelationship {
+    id: string;
+    from: string;
+    to: string;
+    kind: AXPRelationshipKind;
+    cardinality: AXPRelationshipCardinality;
+}
+declare enum AXPEntityCommandScope {
+    TypeLevel = "typeLevel",
+    Selected = "selected",
+    Individual = "individual",
+    Section = "section"
+}
+declare enum AXPEntityQueryType {
+    Single = "single",
+    List = "list"
+}
+interface AXPEntityPropertyLayoutConfig extends AXPGridLayoutOptions {
+    label?: {
+        visible?: boolean;
+    };
+    order?: number;
+    visible?: boolean | AXPExpression;
+}
+interface AXPEntityPropertyGroup {
+    id: string;
+    title: string;
+    description?: string;
+    permissions?: string[];
+    icon?: string;
+}
+interface AXPEntityPropertyView {
+    name: string;
+    dataPath?: string;
+    permissions?: string[];
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView {
+}
+interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {
+    defaultValue?: any;
+}
+interface AXPEntitySectionView {
+    id: string;
+    order?: number;
+    collapsed?: boolean;
+    layout?: AXPEntityPropertyLayoutConfig;
+}
+interface AXPEntityProperty {
+    name: string;
+    title: string;
+    description?: string;
+    groupId?: string;
+    schema: {
+        dataType: string;
+        nullable?: boolean;
+        readonly?: boolean | string;
+        visible?: boolean | string;
+        defaultValue?: any | string | ((context: any | null) => any);
+        unique?: {
+            enabled: boolean;
+        };
+        interface?: Partial<AXEntityPropertyWidget>;
+    };
+    options?: {
+        filter?: {
+            advance?: {
+                enabled?: boolean;
+                widgetType?: string;
+            };
+            inline?: {
+                enabled?: boolean;
+            };
+            preload?: {
+                enabled?: boolean;
+                required?: boolean;
+            };
+        };
+        sort?: {
+            enabled?: boolean;
+        };
+    };
+    validations?: AXPValidationRules;
+}
+/** Logical alignment for table column header/cell (respects RTL). */
+type AXPColumnContentAlign = 'start' | 'center' | 'end';
+/**
+ * Column alignment: shorthand applies to both header and cell;
+ * object form sets each side independently (omitted keys default to start).
+ */
+type AXPColumnAlign = AXPColumnContentAlign | {
+    header?: AXPColumnContentAlign;
+    cell?: AXPColumnContentAlign;
+};
+/** Shared field definition for list layouts (table columns, card fields, etc.). */
+interface AXPEntityDisplayField {
+    name: string;
+    title?: string;
+    showAs?: {
+        type: string;
+        options?: Record<string, any>;
+    };
+    options?: {
+        /** When string, evaluate against parent detail context (e.g. related list). */
+        visible?: boolean | string;
+        /** Optional dataPath override for field binding. */
+        dataPath?: string;
+        [name: string]: any;
+    };
+}
+/** Card layout field presentation in master list card view. */
+type AXPCardFieldDisplay = 'simple' | 'badge';
+/** Badge color: semantic token or per-row expression (`{{ context.eval(...) }}`). */
+type AXPCardBadgeColor = AXStyleColorType | AXPExpression;
+interface AXPCardBadgeDisplayOptions {
+    /** Semantic color or expression evaluated against row context. */
+    color?: AXPCardBadgeColor;
+}
+interface AXPCardBadgeDisplay {
+    type: 'badge';
+    options?: AXPCardBadgeDisplayOptions;
+}
+/** Shorthand (`badge` / `simple`) or structured badge config with optional per-row color. */
+type AXPCardFieldDisplayConfig = AXPCardFieldDisplay | AXPCardBadgeDisplay;
+/** Card layout field in master list view. */
+type AXPCardField = AXPEntityDisplayField & {
+    layout?: AXPEntityPropertyLayoutConfig;
+    /**
+     * Field presentation. Default: `simple` (card body).
+     * Use `badge` or `{ type: 'badge', options: { color } }` for header chips beside title.
+     */
+    display?: AXPCardFieldDisplayConfig;
+    /**
+     * Badge color when presentation is badge-shaped.
+     * Prefer `display: { type: 'badge', options: { color } }` for new definitions.
+     * Omit for status fields — color is resolved from the status definition per row.
+     */
+    badgeColor?: AXPCardBadgeColor;
+};
+/** Whether the card field is shown as a header badge (not in the card body). */
+declare function isCardFieldBadgeDisplay(display: AXPCardFieldDisplayConfig | undefined): display is 'badge' | AXPCardBadgeDisplay;
+/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
+declare function resolveCardFieldBadgeColor(field: Pick<AXPCardField, 'display' | 'badgeColor'>): AXPCardBadgeColor | undefined;
+interface AXPEntityTableColumn extends AXPEntityDisplayField {
+    options?: AXPEntityDisplayField['options'] & {
+        /** Initial column width (overrides widget column width when set). */
+        width?: string;
+        /** Header/cell alignment (shorthand or per-side). */
+        align?: AXPColumnAlign;
+    };
+}
+interface AXPEntityCommand {
+    execute: string | Function;
+    permissions?: string[];
+}
+interface AXPEntityQuery {
+    execute: string | Function;
+    type: AXPEntityQueryType;
+}
+type AXPCommandActionType = AXPSystemActionType;
+interface AXPCommandActionLook {
+    color: AXStyleColorType;
+    icon: string;
+}
+type AXPCommandActionPriority = 'primary' | 'secondary';
+type AXPCommandActionCallback = string | {
+    name: string;
+    options?: {
+        decoration?: {
+            header?: {
+                title?: string;
+            };
+        };
+        process?: {
+            data?: any;
+            [name: string]: any;
+        };
+        layout?: {
+            size?: AXPopupSizeType;
+        };
+        [name: string]: any;
+    };
+    metadata?: AXPMetaData;
+};
+interface AXPCommandActionDisplay extends Partial<AXPCommandActionLook> {
+    name?: string;
+    command: AXPCommandActionCallback;
+    title: string;
+    type: AXPSystemActionType | string;
+    priority: 'primary' | 'secondary' | 'none';
+    separated?: boolean;
+    permissions?: string[];
+    hidden?: boolean | string;
+    disabled?: boolean | string;
+    default?: boolean;
+    order?: number;
+    /**
+     * Keyboard chords for this action (e.g. `'ctrl+shift+a'`).
+     * Pass `[]` to disable shortcuts. When omitted, platform defaults may apply for known commands.
+     */
+    shortcuts?: string[];
+}
+interface AXPEntityAction extends AXPCommandActionDisplay {
+    scope: AXPEntityCommandScope;
+    /** Child actions for dropdown submenu */
+    items?: AXPEntityAction[];
+}
+interface AXPEntity {
+    plugins?: {
+        name: string;
+        options?: AXPOptionsData;
+    }[];
+    /**
+     * High-level rules: when expression evaluates true, apply actions to the given targets
+     * (property/section/action). Reduces repetition of the same condition across many properties.
+     * Evaluation context: form data, user, entity; precedence vs property-level visible/readonly
+     * must be defined where rules are applied.
+     */
+    rules?: Array<{
+        name: string;
+        expression: AXPExpression;
+        actions: Array<{
+            target: {
+                type: 'property' | 'section' | 'action';
+                name: string;
+            };
+            values: AXPOptionsData;
+        }>;
+    }>;
+    module: string;
+    name: string;
+    icon?: string;
+    parentKey?: string;
+    category?: AXPEntityCategoryPlugin;
+    title: string;
+    formats: {
+        individual: string;
+        plural: string;
+        lookup?: string;
+        displayName?: string;
+        searchResult?: {
+            title: string;
+            description?: string;
+        };
+    };
+    relatedEntities?: AXPRelatedEntity[];
+    pages?: AXPEntityPage[];
+    groups?: AXPEntityPropertyGroup[];
+    properties: AXPEntityProperty[];
+    columns?: AXPEntityTableColumn[];
+    commands?: {
+        create?: AXPEntityCommand | undefined;
+        update?: AXPEntityCommand | undefined;
+        delete?: AXPEntityCommand | undefined;
+        [name: string]: AXPEntityCommand | undefined;
+    };
+    queries?: {
+        byKey?: AXPEntityQuery;
+        list?: AXPEntityQuery;
+        lookup?: AXPEntityQuery;
+        history?: AXPEntityQuery;
+        comments?: AXPEntityQuery;
+        [name: string]: AXPEntityQuery | undefined;
+    };
+    validations?: AXPValidationRules;
+    interfaces?: {
+        master?: {
+            single?: AXPEntityMasterSingleLayoutView;
+            list?: AXPEntityMasterListView;
+            create?: AXPEntityMasterCreateLayoutView;
+            update?: AXPEntityMasterUpdateLayoutView;
+        };
+        detail?: {
+            list?: AXPEntityDetailListView;
+        };
+    };
+}
+declare function getEntityInfo(entity: AXPEntity): {
+    source: string;
+    module: {
+        route: string;
+    };
+    entity: {
+        route: string;
+    };
+};
+declare function createQueryView(name: string, title: string, fixed: boolean, params?: {
+    columns?: string[];
+    conditions?: any[];
+    sorts?: AXPQuerySort[];
+}): AXPQueryView;
+declare function createAllQueryView(params?: {
+    columns?: string[];
+    conditions?: AXPQueryFilter[];
+    sorts?: AXPQuerySort[];
+} | undefined): AXPQueryView;
+interface AXPRelatedEntity {
+    entity: string;
+    title?: string;
+    icon?: string;
+    columns?: string[] | AXPEntityTableColumn[];
+    properties?: string[];
+    excludeProperties?: string[];
+    layout?: {
+        type: 'tab-detail' | 'tab-list' | 'page-detail' | 'page-list' | 'merge-detail';
+        order?: number;
+        position?: 'before' | 'after' | 'middle';
+    };
+    conditions?: AXPQueryFilter[];
+    customFilterDefinitions?: Partial<AXPFilterDefinition>[];
+    hidden?: boolean | AXPExpression;
+    actions?: AXPEntityAction[];
+    /**
+     * Controls inclusion on the host entity master **create** / **update** form.
+     * Defaults depend on layout:
+     * - **merge-detail**: omitted flags behave as **true** (opt-out with `false`).
+     * - **tab-list** / **page-list**: omitted flags behave as **false** (opt-in with `true`).
+     */
+    appearOn?: {
+        /** Include on host create form (see defaults above per layout type). */
+        create?: boolean;
+        /** Include on host update form (see defaults above per layout type). */
+        update?: boolean;
+    };
+    /**
+     * Relationship-level persistence strategy for merge-detail data.
+     * Defaults:
+     * - strategy: 'embedded'
+     * - idField: last segment of dataPath + 'Id' (or 'relatedId' when dataPath is missing)
+     * - map: undefined (pass-through)
+     * - hydrate: 'eager' (applies to getOne only in mock)
+     * - cascade.delete: 'none'
+     */
+    persistence?: {
+        strategy?: 'embedded' | 'referenced';
+        idField?: string;
+        dataPath?: string;
+        map?: Record<string, string>;
+        hydrate?: 'eager' | 'lazy';
+        cascade?: {
+            delete?: 'none' | 'orphans' | 'all';
+        };
+        foreignKeyField?: string;
+    };
+}
+interface AXPEntityPage {
+    /**
+     * Key to identify the component in the page component registry
+     */
+    componentKey: string;
+    /**
+     * Property name to render when the page component displays an entity field (e.g. 'questions', 'attachments').
+     * Passed to the page component as pageConfig.field.
+     */
+    field?: string;
+    /**
+     * Title of the page (displayed in navigation)
+     */
+    title?: AXPMultiLanguageString;
+    /**
+     * Icon for the page (displayed in navigation)
+     */
+    icon?: string;
+    /**
+     * Description of the page
+     */
+    description?: AXPMultiLanguageString;
+    /**
+     * Layout configuration for page positioning
+     */
+    layout?: {
+        /**
+         * Order of the page (lower numbers appear first)
+         */
+        order?: number;
+        /**
+         * Position relative to the main page
+         */
+        position?: 'before' | 'after' | 'middle';
+    };
+    /**
+     * Visibility condition (boolean or expression string)
+     */
+    hidden?: boolean | string;
+    /**
+     * Permissions required to view this page
+     */
+    permissions?: string[];
+    /**
+     * Controls inclusion on the host entity master **create** / **update** form wizard.
+     * Omitted flags behave as **false** (opt-in with `true`), same as `tab-list` / `page-list` related entities.
+     */
+    appearOn?: {
+        /** Include as a wizard step on host create form. */
+        create?: boolean;
+        /** Include as a wizard step on host update form. */
+        update?: boolean;
+    };
+    options?: Record<string, any>;
+}
+interface AXPEntityCategoryPlugin {
+    entity: string;
+    title?: string;
+    textField?: string;
+    valueField?: string;
+    conditions?: AXPQueryFilter[];
+    applyConditions?: AXPQueryFilter[];
+}
+interface AXPEntityVersionHistory {
+    enabled?: boolean;
+    showInList?: boolean;
+    showInDetail?: boolean;
+}
+interface AXPAggregate {
+    id: string;
+    name: string;
+    title: AXPMultiLanguageString;
+    entities: AXPEntity[];
+}
+interface AXPModule {
+    name: string;
+    title: AXPMultiLanguageString;
+    aggregates: AXPAggregate[];
+    relationships?: AXPRelationship[];
+}
+interface AXPApplication {
+    name: string;
+    title: AXPMultiLanguageString;
+    modules: AXPModule[];
+}
+interface AXPEntityMasterLayoutView {
+    title?: string;
+    sections: AXPEntitySectionView[];
+    properties?: AXPEntityPropertyView[];
+}
+/** Quick create config for lookup widgets (+ button) - uses subset of create form */
+interface AXPEntityQuickCreate {
+    enabled?: boolean;
+    properties?: string[];
+    layout?: {
+        size?: AXPopupSizeType;
+    };
+    excludeProperties?: string[];
+}
+interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {
+    steps?: {
+        id: string;
+        title: string;
+        description?: string;
+    };
+    /** Quick create config for lookup widgets - uses subset of create form */
+    quickCreate?: AXPEntityQuickCreate;
+}
+interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView {
+}
+interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {
+    title: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+}
+interface AXPEntityMasterListView {
+    title?: string;
+    description?: string;
+    actions?: AXPEntityAction[];
+    views: AXPQueryView[];
+    layouts?: {
+        table?: {
+            enabled?: boolean;
+            columns: AXPEntityTableColumn[];
+        };
+        card?: {
+            enabled?: boolean;
+            header: {
+                /** Property path, expression (`{{ ... }}`), or literal — evaluated per row. */
+                title?: string;
+                description?: string;
+                icon?: string;
+            };
+            fields: AXPCardField[];
+        };
+    };
+}
+type AXPEntityMasterListLayoutType = 'table' | 'card';
+/** Master list presentation: table or card with compact (collapsed) / expanded bodies. */
+type AXPEntityMasterListDisplayMode = 'table' | 'card-compact' | 'card-expanded';
+interface AXPEntityMasterListLayoutOption {
+    id: AXPEntityMasterListLayoutType;
+    title: string;
+    icon?: string;
+}
+/** Resolves master list layouts that are currently enabled. */
+declare function resolveEnabledMasterListLayouts(layouts?: AXPEntityMasterListView['layouts']): AXPEntityMasterListLayoutType[];
+/** First enabled layout; used as the default when no user preference is stored. */
+declare function resolveDefaultMasterListLayout(layouts?: AXPEntityMasterListView['layouts']): AXPEntityMasterListLayoutType;
+interface AXPEntityDetailListView {
+    title?: string;
+    description?: string;
+    columns: AXPEntityTableColumn[];
+    actions?: AXPEntityAction[];
+}
+interface AXPQueryView {
+    name: string;
+    fixed: boolean;
+    title: string;
+    columns: string[];
+    conditions: AXPQueryFilter[];
+    sorts: AXPQuerySort[];
+    indexCol?: boolean;
+    pageSize?: number;
+    visible?: boolean;
+}
+interface AXPQueryFilter {
+    name: string;
+    operator: AXDataSourceOperator;
+    value: any;
+}
+interface AXPQuerySort {
+    name: string;
+    dir: 'asc' | 'desc';
+}
+declare enum AXPEntityType {
+    Entity = 0,
+    AggregateRoot = 1,
+    ValueObject = 2
+}
+interface AXPEntityV2 {
+    version: 2;
+    module: string;
+    aggregate: string;
+    name: string;
+    type: AXPEntityType;
+    icon?: string;
+    title: string;
+    description?: string;
+    plugins?: {
+        name: string;
+        options?: AXPOptionsData;
+    }[];
+    pages?: AXPEntityPage[];
+    groups?: AXPEntityPropertyGroup[];
+    properties: AXPEntityProperty[];
+    formats: {
+        individual: string;
+        plural: string;
+        lookup?: string;
+        displayName?: string;
+        searchResult?: {
+            title: string;
+            description?: string;
+        };
+    };
+    columns?: AXPEntityTableColumn[];
+    validations?: AXPValidationRules;
+    interfaces?: {
+        master?: {
+            single?: AXPEntityMasterSingleLayoutView;
+            list?: AXPEntityMasterListView;
+            create?: AXPEntityMasterCreateLayoutView;
+            update?: AXPEntityMasterUpdateLayoutView;
+        };
+        detail?: {
+            list?: AXPEntityDetailListView;
+        };
+    };
+}
+
+declare function entityMasterCreateAction(): AXPEntityAction;
+declare function entityMasterEditAction(): AXPEntityAction;
+declare function entityMasterBulkDeleteAction(): AXPEntityAction;
+declare function entityMasterViewAction(): AXPEntityAction;
+declare function entityMasterDeleteAction(): AXPEntityAction;
+declare function entityMasterCrudActions(options?: {
+    create?: boolean;
+    delete?: boolean;
+    view?: boolean;
+    edit?: boolean;
+}): AXPEntityAction[];
+declare function entityMasterRecordActions(): AXPEntityAction[];
+declare function entityDetailsCreateActions(parentId: string): AXPEntityAction;
+declare function entityDetailsCreateActionsDeferredParent(): AXPEntityAction;
+declare function mergeForeignKeyFieldIntoCreateActions(foreignKeyField: string | undefined, actions: AXPEntityAction[] | undefined): AXPEntityAction[];
+declare function collectNestedCreateHiddenProperties(relatedEntity: AXPRelatedEntity): string[] | undefined;
+declare function entityDetailsSimpleCondition(fk: string): AXPQueryFilter;
+declare function entityDetailsReferenceCondition(type: string): AXPQueryFilter[];
+declare function entityDetailsEditAction(): AXPEntityAction;
+declare function entityDetailsNewEditAction(): AXPEntityAction;
+declare function entityOverrideDetailsViewAction(): AXPEntityAction;
+declare function entityDetailsCrudActions(parentId?: string, options?: {
+    create?: boolean;
+    delete?: boolean;
+    view?: boolean;
+    edit?: boolean;
+}): AXPEntityAction[];
+declare function entityDetailsReferenceCreateActions(type: string): AXPEntityAction[];
+
+/** Platform entity layout datasource registry names. */
+declare const AXPEntityDataSourceKeys: {
+    readonly Entities: "entities";
+};
+
+/**
+ * Regional and locale-related setting keys used by platform widgets and components.
+ * Most values use the `LocaleManagement:Setting:Regional.*` prefix; definitions live in the locale-management module where applicable.
+ */
+declare enum AXPRegionalSetting {
+    LocaleProfile = "LocaleManagement:Setting:Regional.LocaleProfile",
+    TimeZone = "LocaleManagement:Setting:Regional.TimeZone",
+    Language = "LocaleManagement:Setting:Regional.Language",
+    Country = "LocaleManagement:Setting:Regional.Country",
+    Calendar = "LocaleManagement:Setting:Regional.Calendar",
+    /** User-selected holiday calendars shown on the task board and other calendar views. */
+    CalendarEvents = "LocaleManagement:Setting:Regional.CalendarEvents",
+    FirstDayOfWeek = "LocaleManagement:Setting:Regional.FirstDayOfWeek",
+    WeekendDays = "LocaleManagement:Setting:Regional.WeekendDays",
+    ShortDate = "LocaleManagement:Setting:Regional.ShortDate",
+    MediumDate = "LocaleManagement:Setting:Regional.MediumDate",
+    LongDate = "LocaleManagement:Setting:Regional.LongDate",
+    ShortTime = "LocaleManagement:Setting:Regional.ShortTime",
+    MediumTime = "LocaleManagement:Setting:Regional.MediumTime",
+    LongTime = "LocaleManagement:Setting:Regional.LongTime",
+    MeasurementUnits = "LocaleManagement:Setting:Regional.MeasurementUnits",
+    TemperatureUnits = "LocaleManagement:Setting:Regional.TemperatureUnits",
+    DistanceUnits = "LocaleManagement:Setting:Regional.DistanceUnits",
+    WeightUnits = "LocaleManagement:Setting:Regional.WeightUnits",
+    VolumeUnits = "LocaleManagement:Setting:Regional.VolumeUnits",
+    SpeedUnits = "LocaleManagement:Setting:Regional.SpeedUnits",
+    AreaUnits = "LocaleManagement:Setting:Regional.AreaUnits",
+    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
+    MultiLanguageSupport = "LocaleManagement:Setting:Regional.MultiLanguageSupport"
+}
+
+type AXPWidgetRenderMode = 'view' | 'edit' | 'designer' | 'print' | 'column' | 'filter';
+interface AXPWidgetNode {
+    type: string;
+    mode?: AXPWidgetRenderMode;
+    path?: string;
+    name?: string;
+    visible?: boolean | AXPExpression;
+    defaultValue?: unknown;
+    children?: AXPWidgetNode[];
+    options?: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+    meta?: AXPMetaData;
+    valueTransforms?: AXPValueTransformerFunctions;
+}
+
+declare const AXPWidgetsList: {
+    Editors: {
+        DocumentAttachment: string;
+        TagEditor: string;
+        CheckBox: string;
+        ColorBox: string;
+        ColorPalette: string;
+        DateTimeBox: string;
+        AddressBox: string;
+        Direction: string;
+        LargeTextBox: string;
+        NumberBox: string;
+        UnitValueBox: string;
+        PasswordBox: string;
+        QueryBuilder: string;
+        RichText: string;
+        SelectBox: string;
+        SelectionList: string;
+        TextBox: string;
+        InlineDataTable: string;
+        ToggleSwitch: string;
+        FileTypeExtension: string;
+        MapBox: string;
+        MediaGallery: string;
+        SignatureBox: string;
+        LookupBox: string;
+        MultiSourceSelector: string;
+        EntityCategory: string;
+        ContactBox: string;
+        MetaDataBox: string;
+        TemplateBox: string;
+        TemplateContentEditor: string;
+        TimeDuration: string;
+        DocumentUploader: string;
+        MetaSelector: string;
+        MetaDataForm: string;
+        ColumnFilterSelector: string;
+        DataListFilter: string;
+        ListEditor: string;
+        ConnectedListsEditor: string;
+        SkillMatrix: string;
+        ResponsibilitiesMatrix: string;
+        RiskMatrix: string;
+        ProgressBox: string;
+        RatePicker: string;
+        ActivityCommandConfigurator: string;
+        WorkflowConfigurator: string;
+    };
+    Layouts: {
+        AlertBox: string;
+        BadgeLayout: string;
+        BlockLayout: string;
+        RepeaterLayout: string;
+        TextBlockLayout: string;
+        FormField: string;
+        PanelLayout: string;
+        PageLayout: string;
+        DocumentLayout: string;
+        GridRowLayout: string;
+        GridItemLayout: string;
+        GridLayout: string;
+        FlexLayout: string;
+        FlexItemLayout: string;
+        AdvancedGridLayout: string;
+        AdvancedGridItemLayout: string;
+        FieldsetLayout: string;
+        TabsetLayout: string;
+        TabsetItemLayout: string;
+    };
+    Actions: {
+        ActionButton: string;
+    };
+    Advanced: {
+        CodeEditor: string;
+        JsonViewer: string;
+        OutcomeResultsViewer: string;
+        QRCode: string;
+        schedulerPicker: string;
+        Signature: string;
+        Map: string;
+        Gallery: string;
+        Image: string;
+        ImageMarker: string;
+        Avatar: string;
+        Attachments: string;
+        DataList: string;
+        ListToolbar: string;
+        CronJob: string;
+        Status: string;
+        WidgetFieldConfigurator: string;
+        AnswersViewer: string;
+    };
+    Templates: {
+        Designer: string;
+        Template: string;
+    };
+    Entity: {
+        EntityList: string;
+        SelectorStructure: string;
+    };
+    Providers: {
+        EntityDefinition: string;
+    };
+    ExpressionBuilders: {
+        ConditionBuilder: string;
+    };
+    Theme: {
+        ThemeColorChooser: string;
+        IconChooser: string;
+        FontSizeChooser: string;
+        FontStyleChooser: string;
+    };
+};
+
+declare const AXPWidgetsCatalog: {
+    readonly timeDuration: "time-duration";
+    readonly timeDurationFilter: "time-duration-filter";
+    readonly checkbox: "checkbox-editor";
+    readonly color: "color-editor";
+    readonly connectedLists: "connected-lists-editor";
+    readonly contact: "contact-editor";
+    readonly dateTime: "date-time-editor";
+    readonly largeText: "large-text-editor";
+    readonly number: "number-editor";
+    readonly numberUnit: "number-unit-editor";
+    readonly password: "password-editor";
+    readonly richText: "rich-text-editor";
+    readonly select: "select-editor";
+    readonly selectionList: "selection-list-editor";
+    readonly text: "text-editor";
+    readonly table: "table-editor";
+    readonly toggle: "toggle-editor";
+    readonly blockLayout: "block-layout";
+    readonly pageLayout: "page-layout";
+    readonly repeaterLayout: "repeater-layout";
+    readonly textBlockLayout: "text-block-layout";
+    readonly alertBoxLayout: "alert-box-layout";
+    readonly badgeLayout: "badge-layout";
+    readonly attachments: "attachments";
+    readonly fileTypeExtension: "file-type-extension";
+    readonly map: "map";
+    readonly imageMarker: "image-marker";
+    readonly image: "image";
+    readonly gallery: "gallery";
+    readonly signature: "signature";
+    readonly buttonAction: "button-action";
+    readonly document: "document-layout";
+    readonly lookup: "lookup-editor";
+    readonly formField: "form-field";
+    readonly qrcode: "qrcode";
+    readonly schedulerPicker: "scheduler-picker";
+    readonly advancedGrid: "advanced-grid-layout";
+    readonly advancedGridItem: "advanced-grid-item-layout";
+    readonly grid: "grid-layout";
+    readonly gridItem: "grid-item-layout";
+    readonly template: "template";
+    readonly templateDesigner: "template-designer";
+    readonly cronJob: "cron-job";
+    readonly spacing: "spacing";
+    readonly direction: "direction";
+    readonly border: "border";
+    readonly flexLayout: "flex-layout";
+    readonly flexItem: "flex-item-layout";
+    readonly tableLayout: "table-layout";
+    readonly tableItem: "table-item-layout";
+    readonly avatar: "avatar";
+    readonly themeModeChooser: "theme-mode-chooser";
+    readonly menuOrientationChooser: "menu-orientation-chooser";
+    readonly fontStyleChooser: "font-style-chooser";
+    readonly fontSizeChooser: "font-size-chooser";
+    readonly iconChooser: "icon-chooser";
+    readonly icon: "icon";
+    readonly themeColorChooser: "theme-color-chooser";
+    readonly gridOptions: "grid-options";
+    readonly gridItemOptions: "grid-item-options";
+    readonly advancedGridOptions: "advanced-grid-options";
+    readonly stringFilter: "string-filter";
+    readonly numberFilter: "number-filter";
+    readonly dateTimeFilter: "datetime-filter";
+    readonly booleanFilter: "boolean-filter";
+    readonly lookupFilter: "lookup-filter";
+    readonly flexOptions: "flex-options";
+    readonly flexItemOptions: "flex-item-options";
+    readonly selectFilter: "select-filter";
+    readonly requiredValidation: "required-validation";
+    readonly regularExpressionValidation: "regular-expression-validation";
+    readonly minLengthValidation: "min-length-validation";
+    readonly maxLengthValidation: "max-length-validation";
+    readonly lessThanValidation: "less-than-validation";
+    readonly greaterThanValidation: "greater-than-validation";
+    readonly betweenValidation: "between-validation";
+    readonly equalValidation: "equal-validation";
+    readonly callbackValidation: "callback-validation";
+    readonly metaData: "meta-data-editor";
+    readonly templateEditor: "template-box-editor";
+    readonly templateContentEditor: "template-content-editor";
+    readonly panel: "panel";
+    readonly notification: "notification";
+    readonly comment: "comment";
+    readonly list: "list-editor";
+    readonly dataList: "data-list";
+    readonly listToolbar: "list-toolbar";
+    readonly entityList: "entity-list";
+    readonly pageComponent: "page-component";
+    readonly editorJs: "editor-js-editor";
+    readonly documentUploader: "document-uploader";
+    readonly stepWizard: "step-wizard";
+    readonly progressBar: "progress-bar-editor";
+    readonly rate: "rate-picker-editor";
+    readonly documentFileTypeFilter: "document-file-type-filter";
+    readonly entityDefinitionProvider: "entity-definition-provider-editor";
+};
 
 /**
  * Address mode type - determines the display mode of the address widget
@@ -57,6 +1281,21 @@ interface AXPWorkflowDefinition {
      */
     bindings?: AXPWorkflowBinding[];
 }
+/**
+ * Workflow Category - Extends AXPCategoryEntity for consistency and performance
+ *
+ * Inherited properties from AXPCategoryEntity:
+ * - id: string                   - Unique identifier
+ * - title: string                - Display name
+ * - description?: string         - Category description
+ * - parentId?: string            - Parent category ID
+ * - childrenCount: number        - Direct child categories count (enables lazy loading)
+ * - itemsCount?: number          - Direct workflows count
+ * - totalChildrenCount?: number  - Total nested categories (optional, for analytics)
+ * - totalItemsCount?: number     - Total workflows in tree (optional, for analytics)
+ */
+interface AXPWorkflowCategory extends AXPCategoryEntity {
+}
 interface AXPWorkflowGraph {
     startActivityId: string;
     activities: AXPWorkflowActivityInstance[];
@@ -936,5 +2175,441 @@ interface AXPMetaDataDefinition {
     features?: AXPMetaDataFeatures;
 }
 
-export { AXPFileStorageStatus, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY };
-export type { AXPActivityCategory, AXPActivityDefinition, AXPActivityDefinitionCategoryRef, AXPActivityDefinitionQueryResult, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityStatus, AXPActivityVariable, AXPAddressData, AXPAddressLabel, AXPAddressMode, AXPBookmark, AXPCompletionCallbackState, AXPConnection, AXPElsaWorkflowExtensions, AXPExceptionState, AXPFileManyStorageInfo, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPMetaDataDefinition, AXPMetaDataFeatures, AXPTaskType, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowContinuationBeforeInteractive, AXPWorkflowContinuationMetadata, AXPWorkflowDefinition, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInstance, AXPWorkflowOutputProperty, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowSubStatus };
+/** JSON data primitive for the specialist final deliverable. */
+type AXPAgentOutputKind = 'string' | 'object' | 'array';
+/** When `kind` is `object`, controls how the parsed value maps into chat transcript segments. */
+type AXPOutputTranscriptSegmentId = 'text' | 'node' | 'followUp' | 'file';
+
+type AXPSpreadsheetCellValue = string | null;
+/** Matrix data: row id → column id → cell value id */
+type AXPSpreadsheetData = Record<string, Record<string, AXPSpreadsheetCellValue>>;
+
+/** Standard system status types used across the platform. */
+declare enum AXPSystemStatusType {
+    Todo = "todo",
+    InProgress = "in-progress",
+    InReview = "in-review",
+    Open = "open",
+    Closed = "closed",
+    Blocked = "blocked",
+    Done = "done",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    PendingReview = "pending-review",
+    WaitingSignOff = "waiting-sign-off",
+    WaitingApproval = "waiting-approval",
+    Approved = "approved",
+    Published = "published",
+    Archived = "archived",
+    Rejected = "rejected",
+    Active = "active",
+    Inactive = "inactive",
+    Pending = "pending",
+    Completed = "completed",
+    Suspended = "suspended",
+    Failed = "failed",
+    Review = "review",
+    Expired = "expired"
+}
+
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Status definition with metadata
+ */
+interface AXPStatusDefinition {
+    /**
+     * Unique identifier for the status
+     */
+    name: string;
+    /**
+     * Display title for the status
+     */
+    title: string;
+    /**
+     * Color code or semantic color name for the status
+     */
+    color: string;
+    /**
+     * Optional icon class (e.g., 'fa-light fa-check')
+     */
+    icon?: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional order for sorting
+     */
+    order?: number;
+    /**
+     * Whether this is a final status (end state)
+     */
+    isFinal?: boolean;
+    /**
+     * Whether this is an initial status (starting state)
+     */
+    isInitial?: boolean;
+    /**
+     * Whether list views should be automatically generated for this status
+     */
+    generateView?: boolean;
+}
+/**
+ * Status transition definition
+ */
+interface AXPStatusTransition {
+    /**
+     * Source status name
+     */
+    from: string;
+    /**
+     * Target status name
+     */
+    to: string;
+    /**
+     * Optional condition expression to evaluate before allowing transition
+     * Uses expression evaluator syntax (e.g., "{{user.isAdmin}}", "{{item.priority > 5}}")
+     */
+    condition?: string;
+    /**
+     * Optional display title for the transition
+     */
+    title?: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional command descriptor to execute for this transition
+     * If not provided, defaults to Entity:UpdateStatus with entity, id, and status
+     */
+    command?: {
+        name: string;
+        options?: Record<string, unknown>;
+    };
+    /**
+     * Whether this transition is automatic (no user action required)
+     */
+    isAutomatic?: boolean;
+    /**
+     * Whether this transition requires approval
+     */
+    requiresApproval?: boolean;
+}
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+declare abstract class AXPStatusProvider {
+    /**
+     * Unique key for the status (e.g., 'task-management.status')
+     */
+    abstract readonly key: string;
+    /**
+     * List of available status definitions
+     */
+    abstract readonly statuses: AXPStatusDefinition[];
+    /**
+     * List of allowed transitions between statuses
+     */
+    abstract readonly transitions: AXPStatusTransition[];
+    /**
+     * Optional default status name
+     */
+    abstract readonly defaultStatus?: string;
+}
+
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+declare const AXPSystemStatuses: Readonly<{
+    readonly Open: {
+        readonly name: AXPSystemStatusType.Open;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Closed: {
+        readonly name: AXPSystemStatusType.Closed;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Todo: {
+        readonly name: AXPSystemStatusType.Todo;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly InProgress: {
+        readonly name: AXPSystemStatusType.InProgress;
+        readonly title: string;
+        readonly icon: "fa-light fa-play";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly InReview: {
+        readonly name: AXPSystemStatusType.InReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Blocked: {
+        readonly name: AXPSystemStatusType.Blocked;
+        readonly title: string;
+        readonly icon: "fa-light fa-ban";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Done: {
+        readonly name: AXPSystemStatusType.Done;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Cancelled: {
+        readonly name: AXPSystemStatusType.Cancelled;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Draft: {
+        readonly name: AXPSystemStatusType.Draft;
+        readonly title: string;
+        readonly icon: "fa-light fa-file-pen";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly PendingReview: {
+        readonly name: AXPSystemStatusType.PendingReview;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly WaitingSignOff: {
+        readonly name: AXPSystemStatusType.WaitingSignOff;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly WaitingApproval: {
+        readonly name: AXPSystemStatusType.WaitingApproval;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Approved: {
+        readonly name: AXPSystemStatusType.Approved;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 3;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Published: {
+        readonly name: AXPSystemStatusType.Published;
+        readonly title: string;
+        readonly icon: "fa-light fa-globe";
+        readonly color: "primary";
+        readonly description: string;
+        readonly order: 4;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Archived: {
+        readonly name: AXPSystemStatusType.Archived;
+        readonly title: string;
+        readonly icon: "fa-light fa-archive";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Rejected: {
+        readonly name: AXPSystemStatusType.Rejected;
+        readonly title: string;
+        readonly icon: "fa-light fa-times-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 6;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Active: {
+        readonly name: AXPSystemStatusType.Active;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Inactive: {
+        readonly name: AXPSystemStatusType.Inactive;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle";
+        readonly color: "secondary";
+        readonly description: string;
+        readonly order: 2;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Pending: {
+        readonly name: AXPSystemStatusType.Pending;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "warning";
+        readonly description: string;
+        readonly order: 1;
+        readonly isInitial: true;
+        readonly isFinal: false;
+    };
+    readonly Completed: {
+        readonly name: AXPSystemStatusType.Completed;
+        readonly title: string;
+        readonly icon: "fa-light fa-check-circle";
+        readonly color: "success";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Suspended: {
+        readonly name: AXPSystemStatusType.Suspended;
+        readonly title: string;
+        readonly icon: "fa-light fa-pause-circle";
+        readonly color: "neutral";
+        readonly description: string;
+        readonly order: 5;
+        readonly isInitial: false;
+        readonly isFinal: false;
+    };
+    readonly Failed: {
+        readonly name: AXPSystemStatusType.Failed;
+        readonly title: string;
+        readonly icon: "fa-light fa-xmark-circle";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+    readonly Review: {
+        readonly name: AXPSystemStatusType.Review;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "info";
+        readonly description: string;
+        readonly order: 3;
+    };
+    readonly Expired: {
+        readonly name: AXPSystemStatusType.Expired;
+        readonly title: string;
+        readonly icon: "fa-light fa-clock";
+        readonly color: "danger";
+        readonly description: string;
+        readonly order: 10;
+        readonly isInitial: false;
+        readonly isFinal: true;
+    };
+}>;
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+declare function getSystemStatus(type: AXPSystemStatusType): AXPStatusDefinition;
+/**
+ * Resolves the visual appearance (color and icon) for status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Color and icon for the status
+ */
+declare function resolveStatusLook(statusType: string): {
+    color: AXStyleColorType;
+    icon: string;
+};
+/**
+ * Resolves the complete status information (title, description, icon, color) for a status
+ * using the system statuses from the core module.
+ * @param statusType - Status type string
+ * @returns Complete status information as AXPStatusDefinition
+ */
+declare function getStatusInfo(statusType: string): AXPStatusDefinition;
+/**
+ * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
+ * @param statusType - Status type
+ * @param overrides - Optional overrides for the status definition
+ * @returns AXPStatusDefinition
+ */
+declare function systemStatusToDefinition(statusType: AXPSystemStatusType, overrides?: Partial<AXPStatusDefinition>): AXPStatusDefinition;
+
+interface AXPMultiSourceRef {
+    sourceKey: string;
+    refId?: string;
+    displayName: string;
+    data?: unknown;
+    meta?: Record<string, unknown>;
+}
+
+interface AXPLogoConfig {
+    width?: number;
+    height?: number;
+}
+
+export { AXPDataGenerator, AXPEntityCommandScope, AXPEntityDataSourceKeys, AXPEntityQueryType, AXPEntityType, AXPFileStorageStatus, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPStatusProvider, AXPSystemActionType, AXPSystemStatusType, AXPSystemStatuses, AXPWidgetsCatalog, AXPWidgetsList, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, collectNestedCreateHiddenProperties, createAllQueryView, createMultiLanguageString, createQueryView, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, getEntityInfo, getStatusInfo, getSystemStatus, isCardFieldBadgeDisplay, mergeForeignKeyFieldIntoCreateActions, resolveCardFieldBadgeColor, resolveDefaultMasterListLayout, resolveEnabledMasterListLayouts, resolveMultiLanguageString, resolveStatusLook, systemStatusToDefinition };
+export type { AXDataSourceFilterOption, AXDataSourceOperator, AXDataSourceOperatorType, AXEntityPropertyWidget, AXFilterLogic, AXPActivityCategory, AXPActivityDefinition, AXPActivityDefinitionCategoryRef, AXPActivityDefinitionQueryResult, AXPActivityExecutionContextState, AXPActivityIncident, AXPActivityStatus, AXPActivityVariable, AXPAddressData, AXPAddressLabel, AXPAddressMode, AXPAgentOutputKind, AXPAggregate, AXPApplication, AXPAuditEvent, AXPBookmark, AXPCardBadgeColor, AXPCardBadgeDisplay, AXPCardBadgeDisplayOptions, AXPCardField, AXPCardFieldDisplay, AXPCardFieldDisplayConfig, AXPCategorizedEntity, AXPCategorizedEntityDto, AXPCategoryEntity, AXPCategoryEntityWithItems, AXPCategoryListItem, AXPColumnAlign, AXPColumnContentAlign, AXPCommandActionCallback, AXPCommandActionDisplay, AXPCommandActionLook, AXPCommandActionPriority, AXPCommandActionType, AXPCompletionCallbackState, AXPConnection, AXPContent, AXPContentType, AXPDataType, AXPElsaWorkflowExtensions, AXPEntity, AXPEntityAction, AXPEntityCategoryPlugin, AXPEntityCommand, AXPEntityCreateDto, AXPEntityDetailDto, AXPEntityDetailListView, AXPEntityDisplayField, AXPEntityListItemDto, AXPEntityMasterCreateLayoutView, AXPEntityMasterLayoutView, AXPEntityMasterListDisplayMode, AXPEntityMasterListLayoutOption, AXPEntityMasterListLayoutType, AXPEntityMasterListView, AXPEntityMasterSingleLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityModel, AXPEntityOp, AXPEntityOutputDto, AXPEntityPage, AXPEntityProperty, AXPEntityPropertyCreateView, AXPEntityPropertyGroup, AXPEntityPropertyLayoutConfig, AXPEntityPropertyUpdateView, AXPEntityPropertyView, AXPEntityQuery, AXPEntityQuickCreate, AXPEntityReference, AXPEntitySectionView, AXPEntityTableColumn, AXPEntityUpdateDto, AXPEntityV2, AXPEntityVersionHistory, AXPExceptionState, AXPExpression, AXPFileListItem, AXPFileManyStorageInfo, AXPFileSource, AXPFileStatus, AXPFileStorageCreateRequest, AXPFileStorageFindRequest, AXPFileStorageInfo, AXPFileStorageUpdateRequest, AXPFilterClause, AXPFilterDefinition, AXPFilterQuery, AXPFilterTriggerDefinition, AXPGridLayoutOptions, AXPGridPlacement, AXPLogoConfig, AXPMetaData, AXPMetaDataDefinition, AXPMetaDataFeatures, AXPMockDto, AXPModule, AXPMultiLanguageString, AXPMultiSourceRef, AXPOptionsData, AXPOutputTranscriptSegmentId, AXPProperty, AXPPropertyGroup, AXPPropertyInterface, AXPQueryFilter, AXPQuerySort, AXPQueryView, AXPRecordAuditInfo, AXPRecordOwnershipInfo, AXPRecordStateInfo, AXPRecordWorkflowInfo, AXPRelatedEntity, AXPRelationship, AXPSpreadsheetCellValue, AXPSpreadsheetData, AXPStatusDefinition, AXPStatusTransition, AXPTaskType, AXPUserReference, AXPValidationRule, AXPValidationRules, AXPValueTransformerFunction, AXPValueTransformerFunctions, AXPWidgetNode, AXPWidgetRenderMode, AXPWidgetTrigger, AXPWidgetTriggers, AXPWorkflowActivityInstance, AXPWorkflowBinding, AXPWorkflowCategory, AXPWorkflowContinuationBeforeInteractive, AXPWorkflowContinuationMetadata, AXPWorkflowDefinition, AXPWorkflowExtensions, AXPWorkflowFaultState, AXPWorkflowGraph, AXPWorkflowInstance, AXPWorkflowOutputProperty, AXPWorkflowState, AXPWorkflowStatus, AXPWorkflowSubStatus, AXPopupSizeType, AXStyleColorType };