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

package/fesm2022/acorex-platform-contracts.mjs

@@ -1,3 +1,962 @@
+//#region ---- CDK / component shims (pure contracts, no @acorex/cdk) ----
+//#endregion
+
+//#region ---- Mock data shims (no @acorex/core, no @acorex/platform/core) ----
+/**
+ * Builds a locale map for mock seed data (`en-US` + `fa-IR`).
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+function createMultiLanguageString(enUS, faIR) {
+    return {
+        'en-US': enUS,
+        'fa-IR': faIR ?? enUS,
+    };
+}
+/**
+ * Resolves {@link AXPMultiLanguageString} to a plain string for the given locale.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/core/translation.
+ */
+function resolveMultiLanguageString(value, locale) {
+    if (value == null || value === '') {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    const direct = value[locale];
+    if (typeof direct === 'string' && direct.length > 0) {
+        return direct;
+    }
+    const enUS = value['en-US'];
+    if (typeof enUS === 'string' && enUS.length > 0) {
+        return enUS;
+    }
+    for (const entry of Object.values(value)) {
+        if (typeof entry === 'string' && entry.length > 0) {
+            return entry;
+        }
+    }
+    return '';
+}
+/**
+ * Lightweight data helpers for mock seed files.
+ * Standalone copy for connectivity mocks — no dependency on @acorex/platform/core.
+ */
+class AXPDataGenerator {
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const random = (Math.random() * 16) | 0;
+            const value = char === 'x' ? random : (random & 0x3) | 0x8;
+            return value.toString(16);
+        });
+    }
+    static number(...args) {
+        let min = 0;
+        let max = 100;
+        if (args.length === 1)
+            max = args[0];
+        if (args.length === 2) {
+            min = args[0];
+            max = args[1];
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    static date(...args) {
+        let start = new Date(2000, 0, 1);
+        let end = new Date();
+        if (args.length === 1) {
+            start = args[0];
+        }
+        else if (args.length === 2) {
+            start = args[0];
+            end = args[1];
+        }
+        const startTime = start.getTime();
+        const endTime = end.getTime();
+        return new Date(startTime + Math.random() * (endTime - startTime));
+    }
+    static array(length = 5, generator) {
+        return Array.from({ length }, generator);
+    }
+    static pick(...args) {
+        if (args.length < 1) {
+            throw new Error('Invalid parameters');
+        }
+        const items = args[0];
+        const count = args[1] ?? 1;
+        if (count < 1) {
+            throw new Error('Count must be at least 1');
+        }
+        if (count >= items.length) {
+            return [...items].sort(() => Math.random() - 0.5);
+        }
+        const shuffled = items.slice();
+        for (let i = shuffled.length - 1; i > 0; i -= 1) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return count === 1 ? shuffled.slice(0, count)[0] : shuffled.slice(0, count);
+    }
+    static string(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static boolean() {
+        return Math.random() >= 0.5;
+    }
+    static item(array = []) {
+        return array.length > 0 ? array[Math.floor(Math.random() * array.length)] : undefined;
+    }
+    static color(format = 'hex') {
+        const h = Math.floor(Math.random() * 360);
+        const s = Math.floor(Math.random() * 20) + 60;
+        const l = Math.floor(Math.random() * 20) + 40;
+        if (format === 'hsl') {
+            return `hsl(${h}, ${s}%, ${l}%)`;
+        }
+        const { r, g, b } = this.hslToRgb(h, s / 100, l / 100);
+        if (format === 'rgb') {
+            return `rgb(${r}, ${g}, ${b})`;
+        }
+        const toHex = (val) => val.toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    static hslToRgb(h, s, l) {
+        const c = (1 - Math.abs(2 * l - 1)) * s;
+        const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+        const m = l - c / 2;
+        let r = 0;
+        let g = 0;
+        let b = 0;
+        if (h < 60)
+            [r, g, b] = [c, x, 0];
+        else if (h < 120)
+            [r, g, b] = [x, c, 0];
+        else if (h < 180)
+            [r, g, b] = [0, c, x];
+        else if (h < 240)
+            [r, g, b] = [0, x, c];
+        else if (h < 300)
+            [r, g, b] = [x, 0, c];
+        else
+            [r, g, b] = [c, 0, x];
+        return {
+            r: Math.round((r + m) * 255),
+            g: Math.round((g + m) * 255),
+            b: Math.round((b + m) * 255),
+        };
+    }
+    static alphanumeric(length = 10) {
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static alphabet(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static phone() {
+        const areaCode = this.number(100, 999);
+        const exchangeCode = this.number(100, 999);
+        const lineNumber = this.number(1000, 9999);
+        return `${areaCode}-${exchangeCode}-${lineNumber}`;
+    }
+    static firstName() {
+        const firstNames = ['John', 'Allen', 'Jak', 'Rose', 'Kate', 'Liam', 'Olivia', 'Noah', 'Emma', 'Ava'];
+        return this.pick(firstNames);
+    }
+    static lastName() {
+        const lastNames = ['Gates', 'Jonsen', 'Smith', 'Ford', 'Jakson', 'Brown', 'Johnson', 'Williams', 'Jones', 'Garcia'];
+        return this.pick(lastNames);
+    }
+    static email(...args) {
+        const domains = ['gmail.com', 'yahoo.com', 'outlook.com', 'example.com'];
+        const domain = this.pick(domains);
+        const separator = this.pick(['.', '_', '']);
+        const randomSuffix = this.boolean() ? this.number(1, 99).toString() : '';
+        if (args.length === 2) {
+            const firstName = args[0].toLowerCase();
+            const lastName = args[1].toLowerCase();
+            return `${firstName}${separator}${lastName}${randomSuffix}@${domain}`;
+        }
+        const firstName = this.firstName().toLowerCase();
+        const lastName = this.lastName().toLowerCase();
+        return `${firstName}${separator}${lastName}${randomSuffix}@${domain}`;
+    }
+    static country() {
+        const countries = ['USA', 'Canada', 'Mexico', 'Germany', 'France', 'Japan', 'Australia'];
+        return this.pick(countries);
+    }
+    static city() {
+        const cities = ['Los Angeles', 'Toronto', 'Vancouver', 'Berlin', 'Paris', 'Tokyo', 'Sydney'];
+        return this.pick(cities);
+    }
+    static state() {
+        const states = ['NY', 'CA', 'TX', 'ON', 'BC', 'NSW', 'BER', 'IDF', 'TYO'];
+        return this.pick(states);
+    }
+    static address() {
+        const streets = ['Main St', 'High St', 'Maple Ave', 'Oak St', 'Pine St', 'Cedar St'];
+        const streetNumber = this.number(100, 9999);
+        const street = this.pick(streets);
+        const city = this.city();
+        const state = this.state();
+        const zip = this.number(10000, 99999);
+        const country = this.country();
+        return `${streetNumber} ${street}, ${city}, ${state} ${zip}, ${country}`;
+    }
+    static avatar() {
+        return `https://avatar.iran.liara.run/public/${this.pick([35, 22, 16, 6, 31])}`;
+    }
+}
+//#endregion
+
+//#region ---- Core contract types (no Angular / no @acorex/*) ----
+var AXPSystemActionType;
+(function (AXPSystemActionType) {
+    AXPSystemActionType["View"] = "view";
+    AXPSystemActionType["Create"] = "create";
+    AXPSystemActionType["Update"] = "update";
+    AXPSystemActionType["Delete"] = "delete";
+    AXPSystemActionType["Approve"] = "approve";
+    AXPSystemActionType["Reject"] = "reject";
+    AXPSystemActionType["Submit"] = "submit";
+    AXPSystemActionType["Export"] = "export";
+    AXPSystemActionType["Import"] = "import";
+    AXPSystemActionType["Print"] = "print";
+    AXPSystemActionType["Assign"] = "assign";
+    AXPSystemActionType["Lock"] = "lock";
+    AXPSystemActionType["Unlock"] = "unlock";
+    AXPSystemActionType["Share"] = "share";
+    AXPSystemActionType["Configure"] = "configure";
+    AXPSystemActionType["Reorder"] = "reorder";
+    AXPSystemActionType["Preview"] = "preview";
+    AXPSystemActionType["Duplicate"] = "duplicate";
+    AXPSystemActionType["Archive"] = "archive";
+    AXPSystemActionType["Publish"] = "publish";
+    AXPSystemActionType["Unpublish"] = "unpublish";
+    AXPSystemActionType["Upload"] = "upload";
+    AXPSystemActionType["Download"] = "download";
+    AXPSystemActionType["Copy"] = "copy";
+    AXPSystemActionType["Move"] = "move";
+    AXPSystemActionType["Rename"] = "rename";
+    AXPSystemActionType["Restore"] = "restore";
+    AXPSystemActionType["Manage"] = "manage";
+    AXPSystemActionType["Info"] = "info";
+    AXPSystemActionType["Confirm"] = "confirm";
+    AXPSystemActionType["Design"] = "design";
+    AXPSystemActionType["VersionHistory"] = "version-history";
+    AXPSystemActionType["Compare"] = "compare";
+    AXPSystemActionType["Comments"] = "comments";
+    AXPSystemActionType["Sign"] = "sign";
+    AXPSystemActionType["Setup"] = "setup";
+    AXPSystemActionType["Send"] = "send";
+    AXPSystemActionType["Report"] = "report";
+    AXPSystemActionType["Sent"] = "sent";
+    AXPSystemActionType["Review"] = "review";
+    AXPSystemActionType["Generate"] = "generate";
+    AXPSystemActionType["Refresh"] = "refresh";
+    AXPSystemActionType["Reload"] = "reload";
+    AXPSystemActionType["Search"] = "search";
+    AXPSystemActionType["Filter"] = "filter";
+    AXPSystemActionType["Sort"] = "sort";
+    AXPSystemActionType["Start"] = "start";
+    AXPSystemActionType["Stop"] = "stop";
+    AXPSystemActionType["Pause"] = "pause";
+    AXPSystemActionType["Cancel"] = "cancel";
+    AXPSystemActionType["Close"] = "close";
+    AXPSystemActionType["Complete"] = "complete";
+    AXPSystemActionType["Save"] = "save";
+    AXPSystemActionType["SaveAs"] = "save-as";
+    AXPSystemActionType["Sync"] = "sync";
+    AXPSystemActionType["Reset"] = "reset";
+    AXPSystemActionType["Clear"] = "clear";
+    AXPSystemActionType["Distribution"] = "distribution";
+})(AXPSystemActionType || (AXPSystemActionType = {}));
+//#endregion
+
+//#region ---- Category & entity operation types ----
+//#endregion
+
+//#region ---- Property types ----
+//#endregion
+
+//#region ---- Filter types ----
+//#endregion
+
+//#region ---- Entity model & DTO types ----
+//#endregion
+
+var AXPRelationshipKind;
+(function (AXPRelationshipKind) {
+    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
+    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
+    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
+})(AXPRelationshipKind || (AXPRelationshipKind = {}));
+var AXPRelationshipCardinality;
+(function (AXPRelationshipCardinality) {
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
+})(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
+var AXPEntityCommandScope;
+(function (AXPEntityCommandScope) {
+    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
+    AXPEntityCommandScope["Selected"] = "selected";
+    AXPEntityCommandScope["Individual"] = "individual";
+    AXPEntityCommandScope["Section"] = "section";
+})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
+var AXPEntityQueryType;
+(function (AXPEntityQueryType) {
+    AXPEntityQueryType["Single"] = "single";
+    AXPEntityQueryType["List"] = "list";
+})(AXPEntityQueryType || (AXPEntityQueryType = {}));
+/** Whether the card field is shown as a header badge (not in the card body). */
+function isCardFieldBadgeDisplay(display) {
+    if (display === 'badge') {
+        return true;
+    }
+    return typeof display === 'object' && display !== null && display.type === 'badge';
+}
+/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
+function resolveCardFieldBadgeColor(field) {
+    if (typeof field.display === 'object' && field.display.type === 'badge') {
+        return field.display.options?.color ?? field.badgeColor;
+    }
+    if (field.display === 'badge') {
+        return field.badgeColor;
+    }
+    return undefined;
+}
+function kebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
+        .toLowerCase();
+}
+function getEntityInfo(entity) {
+    return {
+        source: `${entity.module}.${entity.name}`,
+        module: {
+            route: kebabCase(entity.module),
+        },
+        entity: {
+            route: kebabCase(entity.name),
+        },
+    };
+}
+function createQueryView(name, title, fixed, params = {
+    columns: [],
+    conditions: [],
+    sorts: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return {
+        name,
+        title,
+        fixed,
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    };
+}
+function createAllQueryView(params = {
+    columns: [],
+    sorts: [],
+    conditions: [],
+}) {
+    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
+    return createQueryView('all', '@general:terms.interface.selection.all-items', true, {
+        columns: params.columns ?? [],
+        conditions: params.conditions ?? [],
+        sorts: params.sorts ?? [],
+    });
+}
+/** Resolves master list layouts that are currently enabled. */
+function resolveEnabledMasterListLayouts(layouts) {
+    if (!layouts) {
+        return ['table'];
+    }
+    const enabled = [];
+    if (layouts.table?.enabled !== false) {
+        enabled.push('table');
+    }
+    if (layouts.card && layouts.card.enabled !== false) {
+        enabled.push('card');
+    }
+    return enabled.length > 0 ? enabled : ['table'];
+}
+/** First enabled layout; used as the default when no user preference is stored. */
+function resolveDefaultMasterListLayout(layouts) {
+    return resolveEnabledMasterListLayouts(layouts)[0];
+}
+// new version
+var AXPEntityType;
+(function (AXPEntityType) {
+    AXPEntityType[AXPEntityType["Entity"] = 0] = "Entity";
+    AXPEntityType[AXPEntityType["AggregateRoot"] = 1] = "AggregateRoot";
+    AXPEntityType[AXPEntityType["ValueObject"] = 2] = "ValueObject";
+})(AXPEntityType || (AXPEntityType = {}));
+
+//#region ---- Entity action helpers (pure data, no Angular) ----
+//#region Master
+function entityMasterCreateAction() {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function entityMasterEditAction() {
+    return {
+        title: '@general:actions.edit.title',
+        command: 'Entity:Update',
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        scope: AXPEntityCommandScope.Individual,
+        default: true,
+    };
+}
+function entityMasterBulkDeleteAction() {
+    return {
+        title: '@general:actions.delete-items.title',
+        command: 'delete-entity',
+        priority: 'primary',
+        type: AXPSystemActionType.Delete,
+        scope: AXPEntityCommandScope.Selected,
+        order: 100,
+    };
+}
+function entityMasterViewAction() {
+    return {
+        title: '@general:actions.view.title',
+        command: 'open-entity',
+        priority: 'secondary',
+        type: AXPSystemActionType.View,
+        scope: AXPEntityCommandScope.Individual,
+        default: true,
+    };
+}
+function entityMasterDeleteAction() {
+    return {
+        title: '@general:actions.delete.title',
+        command: 'delete-entity',
+        priority: 'secondary',
+        type: AXPSystemActionType.Delete,
+        scope: AXPEntityCommandScope.Individual,
+        order: 100,
+        shortcuts: ['ctrl+shift+delete'],
+    };
+}
+function entityMasterCrudActions(options) {
+    const opts = {
+        create: true,
+        delete: true,
+        view: true,
+        edit: false,
+        ...options,
+    };
+    const actions = [];
+    if (opts.create) {
+        actions.push(entityMasterCreateAction());
+    }
+    if (opts.delete) {
+        actions.push(entityMasterBulkDeleteAction());
+        actions.push(entityMasterDeleteAction());
+    }
+    if (opts.view) {
+        actions.push(entityMasterViewAction());
+    }
+    if (opts.edit) {
+        actions.push(entityMasterEditAction());
+    }
+    return actions;
+}
+function entityMasterRecordActions() {
+    return [entityMasterDeleteAction()];
+}
+//#endregion
+//#region Details
+function entityDetailsCreateActions(parentId) {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+            options: {
+                process: {
+                    redirect: false,
+                    canCreateNewOne: true,
+                    data: {
+                        [parentId]: '{{context.eval("id")}}',
+                    },
+                },
+            },
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function entityDetailsCreateActionsDeferredParent() {
+    return {
+        title: '@general:actions.create.title',
+        command: {
+            name: 'Entity:Create',
+            options: {
+                process: {
+                    redirect: false,
+                    canCreateNewOne: true,
+                    data: {},
+                },
+            },
+        },
+        priority: 'primary',
+        type: AXPSystemActionType.Create,
+        scope: AXPEntityCommandScope.TypeLevel,
+    };
+}
+function mergeForeignKeyFieldIntoCreateActions(foreignKeyField, actions) {
+    if (!foreignKeyField || !actions?.length) {
+        return actions ?? [];
+    }
+    return actions.map((a) => {
+        const cmd = a.command;
+        if (typeof cmd !== 'object' ||
+            !cmd ||
+            cmd.name !== 'Entity:Create' ||
+            a.scope !== AXPEntityCommandScope.TypeLevel) {
+            return a;
+        }
+        const opts = (cmd.options ?? {});
+        const proc = (opts['process'] ?? {});
+        const data = { ...(proc['data'] ?? {}) };
+        if (data[foreignKeyField] === undefined || data[foreignKeyField] === null || data[foreignKeyField] === '') {
+            data[foreignKeyField] = '{{ context.eval("id") }}';
+        }
+        return {
+            ...a,
+            command: {
+                ...cmd,
+                options: { ...opts, process: { ...proc, data } },
+            },
+        };
+    });
+}
+function collectNestedCreateHiddenProperties(relatedEntity) {
+    const fk = relatedEntity.persistence?.foreignKeyField;
+    const merged = [...(relatedEntity.excludeProperties ?? [])];
+    if (fk) {
+        merged.push(fk);
+    }
+    const unique = [...new Set(merged)];
+    return unique.length ? unique : undefined;
+}
+function entityDetailsSimpleCondition(fk) {
+    return {
+        name: fk,
+        operator: { type: 'equal' },
+        value: '{{context.eval("id")}}',
+    };
+}
+function entityDetailsReferenceCondition(type) {
+    return [
+        {
+            name: 'reference.id',
+            operator: { type: 'equal' },
+            value: '{{context.eval("id")}}',
+        },
+        {
+            name: 'reference.type',
+            operator: { type: 'equal' },
+            value: type,
+        },
+    ];
+}
+function entityDetailsEditAction() {
+    return {
+        title: '@general:actions.edit.title',
+        command: 'Entity:Update',
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        default: true,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityDetailsNewEditAction() {
+    return {
+        title: 'New Edit',
+        command: {
+            name: 'Entity:Update',
+        },
+        priority: 'secondary',
+        type: AXPSystemActionType.Update,
+        default: true,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityOverrideDetailsViewAction() {
+    return {
+        title: '@general:actions.view.title',
+        command: 'open-entity',
+        priority: 'secondary',
+        hidden: true,
+        type: AXPSystemActionType.View,
+        scope: AXPEntityCommandScope.Individual,
+    };
+}
+function entityDetailsCrudActions(parentId, options) {
+    const opts = {
+        create: true,
+        delete: true,
+        view: true,
+        edit: true,
+        ...options,
+    };
+    const actions = [];
+    if (opts.create) {
+        if (parentId) {
+            actions.push(entityDetailsCreateActions(parentId));
+        }
+        else {
+            actions.push(entityDetailsCreateActionsDeferredParent());
+        }
+    }
+    if (opts.edit) {
+        actions.push(entityDetailsEditAction());
+    }
+    if (opts.view) {
+        actions.push(entityOverrideDetailsViewAction());
+    }
+    return actions;
+}
+function entityDetailsReferenceCreateActions(type) {
+    return [
+        {
+            title: '@general:actions.create.title',
+            command: {
+                name: 'Entity:Create',
+                options: {
+                    process: {
+                        redirect: false,
+                        canCreateNewOne: true,
+                        data: {
+                            reference: {
+                                id: '{{context.eval("id")}}',
+                                type: type,
+                            },
+                        },
+                    },
+                },
+            },
+            priority: 'primary',
+            type: AXPSystemActionType.Create,
+            scope: AXPEntityCommandScope.TypeLevel,
+        },
+        entityDetailsEditAction(),
+        entityOverrideDetailsViewAction(),
+    ];
+}
+//#endregion
+
+//#region ---- Entity datasource keys ----
+/** Platform entity layout datasource registry names. */
+const AXPEntityDataSourceKeys = {
+    Entities: 'entities',
+};
+//#endregion
+
+//#region ---- Regional setting keys ----
+/**
+ * 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.
+ */
+var AXPRegionalSetting;
+(function (AXPRegionalSetting) {
+    AXPRegionalSetting["LocaleProfile"] = "LocaleManagement:Setting:Regional.LocaleProfile";
+    AXPRegionalSetting["TimeZone"] = "LocaleManagement:Setting:Regional.TimeZone";
+    AXPRegionalSetting["Language"] = "LocaleManagement:Setting:Regional.Language";
+    AXPRegionalSetting["Country"] = "LocaleManagement:Setting:Regional.Country";
+    AXPRegionalSetting["Calendar"] = "LocaleManagement:Setting:Regional.Calendar";
+    /** User-selected holiday calendars shown on the task board and other calendar views. */
+    AXPRegionalSetting["CalendarEvents"] = "LocaleManagement:Setting:Regional.CalendarEvents";
+    AXPRegionalSetting["FirstDayOfWeek"] = "LocaleManagement:Setting:Regional.FirstDayOfWeek";
+    AXPRegionalSetting["WeekendDays"] = "LocaleManagement:Setting:Regional.WeekendDays";
+    AXPRegionalSetting["ShortDate"] = "LocaleManagement:Setting:Regional.ShortDate";
+    AXPRegionalSetting["MediumDate"] = "LocaleManagement:Setting:Regional.MediumDate";
+    AXPRegionalSetting["LongDate"] = "LocaleManagement:Setting:Regional.LongDate";
+    AXPRegionalSetting["ShortTime"] = "LocaleManagement:Setting:Regional.ShortTime";
+    AXPRegionalSetting["MediumTime"] = "LocaleManagement:Setting:Regional.MediumTime";
+    AXPRegionalSetting["LongTime"] = "LocaleManagement:Setting:Regional.LongTime";
+    AXPRegionalSetting["MeasurementUnits"] = "LocaleManagement:Setting:Regional.MeasurementUnits";
+    AXPRegionalSetting["TemperatureUnits"] = "LocaleManagement:Setting:Regional.TemperatureUnits";
+    AXPRegionalSetting["DistanceUnits"] = "LocaleManagement:Setting:Regional.DistanceUnits";
+    AXPRegionalSetting["WeightUnits"] = "LocaleManagement:Setting:Regional.WeightUnits";
+    AXPRegionalSetting["VolumeUnits"] = "LocaleManagement:Setting:Regional.VolumeUnits";
+    AXPRegionalSetting["SpeedUnits"] = "LocaleManagement:Setting:Regional.SpeedUnits";
+    AXPRegionalSetting["AreaUnits"] = "LocaleManagement:Setting:Regional.AreaUnits";
+    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
+    AXPRegionalSetting["MultiLanguageSupport"] = "LocaleManagement:Setting:Regional.MultiLanguageSupport";
+})(AXPRegionalSetting || (AXPRegionalSetting = {}));
+//#endregion
+
+//#region ---- Widget node types ----
+//#endregion
+
+const AXPWidgetsList = {
+    Editors: {
+        DocumentAttachment: 'document-attachment-editor',
+        TagEditor: 'tag-editor',
+        CheckBox: 'checkbox-editor',
+        ColorBox: 'color-editor',
+        ColorPalette: 'color-palette-editor',
+        DateTimeBox: 'date-time-editor',
+        AddressBox: 'address-editor',
+        Direction: 'direction',
+        LargeTextBox: 'large-text-editor',
+        NumberBox: 'number-editor',
+        UnitValueBox: 'number-unit-editor',
+        PasswordBox: 'password-editor',
+        QueryBuilder: 'query-builder-editor',
+        RichText: 'rich-text-editor',
+        SelectBox: 'select-editor',
+        SelectionList: 'selection-list-editor',
+        TextBox: 'text-editor',
+        InlineDataTable: 'table-editor',
+        ToggleSwitch: 'toggle-editor',
+        FileTypeExtension: 'file-type-extension',
+        MapBox: 'map',
+        MediaGallery: 'gallery',
+        SignatureBox: 'signature',
+        LookupBox: 'lookup-editor',
+        MultiSourceSelector: 'multi-source-selector-editor',
+        EntityCategory: 'entity-category-editor',
+        ContactBox: 'contact-editor',
+        MetaDataBox: 'meta-data-editor',
+        TemplateBox: 'template-box-editor',
+        TemplateContentEditor: 'template-content-editor',
+        TimeDuration: 'time-duration',
+        DocumentUploader: 'document-uploader',
+        MetaSelector: 'meta-selector-editor',
+        MetaDataForm: 'meta-data-form-editor',
+        ColumnFilterSelector: 'column-filter-selector-editor',
+        DataListFilter: 'data-list-filter-editor',
+        ListEditor: 'list-editor',
+        ConnectedListsEditor: 'connected-lists-editor',
+        SkillMatrix: 'skill-matrix-editor',
+        ResponsibilitiesMatrix: 'responsibilities-matrix-editor',
+        RiskMatrix: 'risk-matrix-editor',
+        ProgressBox: 'progress-bar-editor',
+        RatePicker: 'rate-picker-editor',
+        ActivityCommandConfigurator: 'activity-command-configurator',
+        WorkflowConfigurator: 'workflow-configurator',
+    },
+    Layouts: {
+        AlertBox: 'alert-box-layout',
+        BadgeLayout: 'badge-layout',
+        BlockLayout: 'block-layout',
+        RepeaterLayout: 'repeater-layout',
+        TextBlockLayout: 'text-block-layout',
+        FormField: 'form-field',
+        PanelLayout: 'panel-layout',
+        PageLayout: 'page-layout',
+        DocumentLayout: 'document-layout',
+        GridRowLayout: 'grid-row-layout',
+        GridItemLayout: 'grid-item-layout',
+        GridLayout: 'grid-layout',
+        FlexLayout: 'flex-layout',
+        FlexItemLayout: 'flex-item-layout',
+        AdvancedGridLayout: 'advanced-grid-layout',
+        AdvancedGridItemLayout: 'advanced-grid-item-layout',
+        FieldsetLayout: 'fieldset-layout',
+        TabsetLayout: 'tabset-layout',
+        TabsetItemLayout: 'tabset-item',
+    },
+    Actions: {
+        ActionButton: 'button-action',
+    },
+    Advanced: {
+        CodeEditor: 'code-editor',
+        JsonViewer: 'json-viewer',
+        OutcomeResultsViewer: 'outcome-results-viewer',
+        QRCode: 'qrcode',
+        schedulerPicker: 'scheduler-picker',
+        Signature: 'signature',
+        Map: 'map',
+        Gallery: 'gallery',
+        Image: 'image',
+        ImageMarker: 'image-marker',
+        Avatar: 'avatar',
+        Attachments: 'attachments',
+        DataList: 'data-list',
+        ListToolbar: 'list-toolbar',
+        CronJob: 'cron-job',
+        Status: 'status-widget',
+        WidgetFieldConfigurator: 'widget-field-configurator',
+        AnswersViewer: 'answers-viewer',
+    },
+    Templates: {
+        Designer: 'template-designer',
+        Template: 'template',
+    },
+    // Filters: {
+    //   StringFilter: 'string-filter',
+    //   SelectFilter: 'select-filter',
+    //   NumberFilter: 'number-filter',
+    //   DateTimeFilter: 'datetime-filter',
+    //   BooleanFilter: 'boolean-filter',
+    //   LookupFilter: 'lookup-filter',
+    // },
+    // PropertyEditors: {
+    //   Spacing: 'spacing',
+    //   GridOptions: 'grid-options',
+    //   GridItemOptions: 'grid-item-options',
+    //   FlexOptions: 'flex-options',
+    //   FlexItemOptions: 'flex-item-options',
+    //   Direction: 'direction',
+    //   Border: 'border',
+    //   AdvancedGridOptions: 'advanced-grid-options',
+    // },
+    // Validations: {
+    //   RequiredValidation: 'required-validation',
+    //   RegularExpressionValidation: 'regular-expression-validation',
+    //   MinLengthValidation: 'min-length-validation',
+    //   MaxLengthValidation: 'max-length-validation',
+    //   LessThanValidation: 'less-than-validation',
+    //   GreaterThanValidation: 'greater-than-validation',
+    //   EqualValidation: 'equal-validation',
+    //   CallbackValidation: 'callback-validation',
+    //   BetweenValidation: 'between-validation',
+    // },
+    Entity: {
+        EntityList: 'entity-list',
+        SelectorStructure: 'selector-structure',
+    },
+    Providers: {
+        EntityDefinition: 'entity-definition-provider-editor',
+    },
+    ExpressionBuilders: {
+        ConditionBuilder: 'condition-builder-editor',
+    },
+    Theme: {
+        ThemeColorChooser: 'theme-color-chooser',
+        // ThemeModeChooser: 'theme-mode-chooser',
+        IconChooser: 'icon-chooser',
+        FontSizeChooser: 'font-size-chooser',
+        FontStyleChooser: 'font-style-chooser',
+        // MenuOrientationChooser: 'menu-orientation-chooser',
+    },
+    // Features: {
+    //   Comment: 'comment',
+    //   Permissions: 'permissions',
+    // },
+};
+
+//#region ---- Widget catalog (deprecated; prefer AXPWidgetsList) ----
+const AXPWidgetsCatalog = {
+    timeDuration: 'time-duration',
+    timeDurationFilter: 'time-duration-filter',
+    checkbox: 'checkbox-editor',
+    color: 'color-editor',
+    connectedLists: 'connected-lists-editor',
+    contact: 'contact-editor',
+    dateTime: 'date-time-editor',
+    largeText: 'large-text-editor',
+    number: 'number-editor',
+    numberUnit: 'number-unit-editor',
+    password: 'password-editor',
+    richText: 'rich-text-editor',
+    select: 'select-editor',
+    selectionList: 'selection-list-editor',
+    text: 'text-editor',
+    table: 'table-editor',
+    toggle: 'toggle-editor',
+    blockLayout: 'block-layout',
+    pageLayout: 'page-layout',
+    repeaterLayout: 'repeater-layout',
+    textBlockLayout: 'text-block-layout',
+    alertBoxLayout: 'alert-box-layout',
+    badgeLayout: 'badge-layout',
+    attachments: 'attachments',
+    fileTypeExtension: 'file-type-extension',
+    map: 'map',
+    imageMarker: 'image-marker',
+    image: 'image',
+    gallery: 'gallery',
+    signature: 'signature',
+    buttonAction: 'button-action',
+    document: 'document-layout',
+    lookup: 'lookup-editor',
+    formField: 'form-field',
+    qrcode: 'qrcode',
+    schedulerPicker: 'scheduler-picker',
+    advancedGrid: 'advanced-grid-layout',
+    advancedGridItem: 'advanced-grid-item-layout',
+    grid: 'grid-layout',
+    gridItem: 'grid-item-layout',
+    template: 'template',
+    templateDesigner: 'template-designer',
+    cronJob: 'cron-job',
+    spacing: 'spacing',
+    direction: 'direction',
+    border: 'border',
+    flexLayout: 'flex-layout',
+    flexItem: 'flex-item-layout',
+    tableLayout: 'table-layout',
+    tableItem: 'table-item-layout',
+    avatar: 'avatar',
+    themeModeChooser: 'theme-mode-chooser',
+    menuOrientationChooser: 'menu-orientation-chooser',
+    fontStyleChooser: 'font-style-chooser',
+    fontSizeChooser: 'font-size-chooser',
+    iconChooser: 'icon-chooser',
+    icon: 'icon',
+    themeColorChooser: 'theme-color-chooser',
+    gridOptions: 'grid-options',
+    gridItemOptions: 'grid-item-options',
+    advancedGridOptions: 'advanced-grid-options',
+    stringFilter: 'string-filter',
+    numberFilter: 'number-filter',
+    dateTimeFilter: 'datetime-filter',
+    booleanFilter: 'boolean-filter',
+    lookupFilter: 'lookup-filter',
+    flexOptions: 'flex-options',
+    flexItemOptions: 'flex-item-options',
+    selectFilter: 'select-filter',
+    requiredValidation: 'required-validation',
+    regularExpressionValidation: 'regular-expression-validation',
+    minLengthValidation: 'min-length-validation',
+    maxLengthValidation: 'max-length-validation',
+    lessThanValidation: 'less-than-validation',
+    greaterThanValidation: 'greater-than-validation',
+    betweenValidation: 'between-validation',
+    equalValidation: 'equal-validation',
+    callbackValidation: 'callback-validation',
+    metaData: 'meta-data-editor',
+    templateEditor: 'template-box-editor',
+    templateContentEditor: 'template-content-editor',
+    panel: 'panel',
+    notification: 'notification',
+    comment: 'comment',
+    list: 'list-editor',
+    dataList: 'data-list',
+    listToolbar: 'list-toolbar',
+    entityList: 'entity-list',
+    pageComponent: 'page-component',
+    editorJs: 'editor-js-editor',
+    documentUploader: 'document-uploader',
+    stepWizard: 'step-wizard',
+    progressBar: 'progress-bar-editor',
+    rate: 'rate-picker-editor',
+    documentFileTypeFilter: 'document-file-type-filter',
+    entityDefinitionProvider: 'entity-definition-provider-editor',
+};
+//#endregion
+
 //#region ----   Address Data Types   ----
 //#endregion
 
@@ -27,6 +986,376 @@ var AXPFileStorageStatus;
     AXPFileStorageStatus["Error"] = "error";
 })(AXPFileStorageStatus || (AXPFileStorageStatus = {}));
 
+//#region ---- AI output contract types ----
+//#endregion
+
+//#region ---- Spreadsheet data types ----
+//#endregion
+
+//#region ---- System status types ----
+/** Standard system status types used across the platform. */
+var AXPSystemStatusType;
+(function (AXPSystemStatusType) {
+    AXPSystemStatusType["Todo"] = "todo";
+    AXPSystemStatusType["InProgress"] = "in-progress";
+    AXPSystemStatusType["InReview"] = "in-review";
+    AXPSystemStatusType["Open"] = "open";
+    AXPSystemStatusType["Closed"] = "closed";
+    AXPSystemStatusType["Blocked"] = "blocked";
+    AXPSystemStatusType["Done"] = "done";
+    AXPSystemStatusType["Cancelled"] = "cancelled";
+    AXPSystemStatusType["Draft"] = "draft";
+    AXPSystemStatusType["PendingReview"] = "pending-review";
+    AXPSystemStatusType["WaitingSignOff"] = "waiting-sign-off";
+    AXPSystemStatusType["WaitingApproval"] = "waiting-approval";
+    AXPSystemStatusType["Approved"] = "approved";
+    AXPSystemStatusType["Published"] = "published";
+    AXPSystemStatusType["Archived"] = "archived";
+    AXPSystemStatusType["Rejected"] = "rejected";
+    AXPSystemStatusType["Active"] = "active";
+    AXPSystemStatusType["Inactive"] = "inactive";
+    AXPSystemStatusType["Pending"] = "pending";
+    AXPSystemStatusType["Completed"] = "completed";
+    AXPSystemStatusType["Suspended"] = "suspended";
+    AXPSystemStatusType["Failed"] = "failed";
+    AXPSystemStatusType["Review"] = "review";
+    AXPSystemStatusType["Expired"] = "expired";
+})(AXPSystemStatusType || (AXPSystemStatusType = {}));
+//#endregion
+
+/**
+ * Status Definition Types
+ * Defines the structure for status definitions and their transitions
+ */
+/**
+ * Abstract class for status providers
+ * Similar to AXPTaskBadgeProvider pattern
+ */
+class AXPStatusProvider {
+}
+//#endregion
+
+const i18n = (key) => `@general:statuses.${key}`;
+/**
+ * Standard system status definitions
+ * Provides consistent status definitions across the platform
+ * Uses AXPStatusDefinition interface from status-definition.types.ts
+ */
+const AXPSystemStatuses = Object.freeze({
+    Open: {
+        name: AXPSystemStatusType.Open,
+        title: i18n('open.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('open.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Closed: {
+        name: AXPSystemStatusType.Closed,
+        title: i18n('closed.title'),
+        icon: 'fa-light fa-circle',
+        color: 'danger',
+        description: i18n('closed.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: true,
+    },
+    Todo: {
+        name: AXPSystemStatusType.Todo,
+        title: i18n('todo.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('todo.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    InProgress: {
+        name: AXPSystemStatusType.InProgress,
+        title: i18n('in-progress.title'),
+        icon: 'fa-light fa-play',
+        color: 'info',
+        description: i18n('in-progress.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    InReview: {
+        name: AXPSystemStatusType.InReview,
+        title: i18n('in-review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('in-review.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Blocked: {
+        name: AXPSystemStatusType.Blocked,
+        title: i18n('blocked.title'),
+        icon: 'fa-light fa-ban',
+        color: 'danger',
+        description: i18n('blocked.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Done: {
+        name: AXPSystemStatusType.Done,
+        title: i18n('done.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('done.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Cancelled: {
+        name: AXPSystemStatusType.Cancelled,
+        title: i18n('cancelled.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'neutral',
+        description: i18n('cancelled.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Draft: {
+        name: AXPSystemStatusType.Draft,
+        title: i18n('draft.title'),
+        icon: 'fa-light fa-file-pen',
+        color: 'neutral',
+        description: i18n('draft.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    PendingReview: {
+        name: AXPSystemStatusType.PendingReview,
+        title: i18n('pending-review.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending-review.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    WaitingSignOff: {
+        name: AXPSystemStatusType.WaitingSignOff,
+        title: i18n('waiting-sign-off.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('waiting-sign-off.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    WaitingApproval: {
+        name: AXPSystemStatusType.WaitingApproval,
+        title: i18n('waiting-approval.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('waiting-approval.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Approved: {
+        name: AXPSystemStatusType.Approved,
+        title: i18n('approved.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('approved.description'),
+        order: 3,
+        isInitial: false,
+        isFinal: false,
+    },
+    Published: {
+        name: AXPSystemStatusType.Published,
+        title: i18n('published.title'),
+        icon: 'fa-light fa-globe',
+        color: 'primary',
+        description: i18n('published.description'),
+        order: 4,
+        isInitial: false,
+        isFinal: false,
+    },
+    Archived: {
+        name: AXPSystemStatusType.Archived,
+        title: i18n('archived.title'),
+        icon: 'fa-light fa-archive',
+        color: 'danger',
+        description: i18n('archived.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: true,
+    },
+    Rejected: {
+        name: AXPSystemStatusType.Rejected,
+        title: i18n('rejected.title'),
+        icon: 'fa-light fa-times-circle',
+        color: 'danger',
+        description: i18n('rejected.description'),
+        order: 6,
+        isInitial: false,
+        isFinal: true,
+    },
+    Active: {
+        name: AXPSystemStatusType.Active,
+        title: i18n('active.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('active.description'),
+        order: 1,
+        isInitial: false,
+        isFinal: false,
+    },
+    Inactive: {
+        name: AXPSystemStatusType.Inactive,
+        title: i18n('inactive.title'),
+        icon: 'fa-light fa-circle',
+        color: 'secondary',
+        description: i18n('inactive.description'),
+        order: 2,
+        isInitial: false,
+        isFinal: false,
+    },
+    Pending: {
+        name: AXPSystemStatusType.Pending,
+        title: i18n('pending.title'),
+        icon: 'fa-light fa-clock',
+        color: 'warning',
+        description: i18n('pending.description'),
+        order: 1,
+        isInitial: true,
+        isFinal: false,
+    },
+    Completed: {
+        name: AXPSystemStatusType.Completed,
+        title: i18n('completed.title'),
+        icon: 'fa-light fa-check-circle',
+        color: 'success',
+        description: i18n('completed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Suspended: {
+        name: AXPSystemStatusType.Suspended,
+        title: i18n('suspended.title'),
+        icon: 'fa-light fa-pause-circle',
+        color: 'neutral',
+        description: i18n('suspended.description'),
+        order: 5,
+        isInitial: false,
+        isFinal: false,
+    },
+    Failed: {
+        name: AXPSystemStatusType.Failed,
+        title: i18n('failed.title'),
+        icon: 'fa-light fa-xmark-circle',
+        color: 'danger',
+        description: i18n('failed.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+    Review: {
+        name: AXPSystemStatusType.Review,
+        title: i18n('review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'info',
+        description: i18n('review.description'),
+        order: 3,
+    },
+    Expired: {
+        name: AXPSystemStatusType.Expired,
+        title: i18n('expired.title'),
+        icon: 'fa-light fa-clock',
+        color: 'danger',
+        description: i18n('expired.description'),
+        order: 10,
+        isInitial: false,
+        isFinal: true,
+    },
+});
+/**
+ * Get system status definition by type
+ * @param type - Status type
+ * @returns System status definition or undefined
+ */
+function getSystemStatus(type) {
+    return Object.values(AXPSystemStatuses).find(status => status.name === type);
+}
+/**
+ * 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
+ */
+function resolveStatusLook(statusType) {
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            return {
+                color: systemStatus.color,
+                icon: systemStatus.icon || ''
+            };
+        }
+    }
+    return {
+        color: 'secondary',
+        icon: ''
+    };
+}
+/**
+ * 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
+ */
+function getStatusInfo(statusType) {
+    const systemStatusType = statusType;
+    if (systemStatusType) {
+        const systemStatus = getSystemStatus(systemStatusType);
+        if (systemStatus) {
+            return systemStatus;
+        }
+    }
+    return {
+        name: statusType,
+        title: statusType,
+        description: `Status: ${statusType}`,
+        icon: '',
+        color: 'secondary'
+    };
+}
+/**
+ * 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
+ */
+function systemStatusToDefinition(statusType, overrides) {
+    const systemStatus = getSystemStatus(statusType);
+    if (!systemStatus) {
+        throw new Error(`System status ${statusType} not found`);
+    }
+    return {
+        ...systemStatus,
+        ...overrides,
+    };
+}
+
+//#region ---- Multi-source reference ----
+//#endregion
+
+//#region ---- Logo config ----
+//#endregion
+
 //#region ---- Contracts barrel ----
 //#endregion
 
@@ -34,5 +1363,5 @@ var AXPFileStorageStatus;
  * Generated bundle index. Do not edit.
  */
 
-export { AXPFileStorageStatus, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY };
+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 };
 //# sourceMappingURL=acorex-platform-contracts.mjs.map