@acorex-platform/module-platform-management-client 0.0.38 → 0.0.48

package/fesm2022/acorex-platform-module-platform-management-client-contracts-entities-entity-definition.mjs

@@ -1,5 +1,6 @@
-import { AXPWidgetsCatalog, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
-import { entityMasterRecordActions, entityMasterViewAction, createAllQueryView } from '@acorex-platform/framework-shared/entity';
+import { AXPWidgetsList, AXPWidgetsCatalog } from '@acorex-platform/framework-shared/core';
+import { entityMasterCrudActions, entityMasterRecordActions, createAllQueryView, entityMasterCreateAction, entityMasterViewAction } from '@acorex-platform/framework-shared/entity';
+import { ENTITY_CREATE_UI, ENTITY_EDIT_UI, ENTITY_REMOVE_UI } from '@acorex-platform/framework-shared/runtime';
 
 const config = {
     i18n: 'platform-management',
@@ -23,6 +24,12 @@ const RootConfig = {
             title: `@${config.i18n}:tokens.entities.token.title`,
             icon: 'fa-light fa-object-exclude',
         },
+        moduleDefinition: {
+            name: 'ModuleDefinition',
+            title: `@${config.i18n}:module-definitions.entities.module-definition.title`,
+            titlePlural: `@${config.i18n}:module-definitions.entities.module-definition.title-plural`,
+            icon: 'fa-light fa-layer-group',
+        },
         commandDefinition: {
             name: 'CommandDefinition',
             title: `@${config.i18n}:command-definitions.entities.command-definition.title`,
@@ -89,8 +96,1233 @@ const RootConfig = {
     },
 };
 
+//#region ----- Entity definition wizard page keys -----
+/** Schema step: plugins, groups, and properties. */
+const ENTITY_DEFINITION_SCHEMA_PAGE_COMPONENT_KEY = 'entity-definition-schema-page';
+/** Surfaces step: columns, layouts, actions, related entities. */
+const ENTITY_DEFINITION_SURFACES_PAGE_COMPONENT_KEY = 'entity-definition-surfaces-page';
+const ENTITY_DEFINITION_SCHEMA_PROPERTY_NAMES = ['plugins', 'groups', 'properties'];
+const ENTITY_DEFINITION_SURFACES_PROPERTY_NAMES = [
+    'columns',
+    'relatedEntities',
+    'createSections',
+    'createProperties',
+    'listActions',
+    'singleActions',
+    'pages',
+    'rules',
+    'validations',
+    'commandsJson',
+    'queriesJson',
+];
+const ENTITY_DEFINITION_DESIGNER_FORM_KEYS = [
+    'title',
+    'icon',
+    'module',
+    'parentKey',
+    'searchTags',
+    'formatIndividual',
+    'formatPlural',
+    'formatDisplayName',
+    'formatSearchTitle',
+    'formatSearchDescription',
+    'categoryEntity',
+    'categoryTextField',
+    'categoryValueField',
+    'plugins',
+    'groups',
+    'properties',
+    'columns',
+    'relatedEntities',
+    'createSections',
+    'createProperties',
+    'listActions',
+    'singleActions',
+    'pages',
+    'rules',
+    'validations',
+    'commandsJson',
+    'queriesJson',
+];
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const i18n$1 = RootConfig.config.i18n;
+const field = (name) => `@${i18n$1}:entity-definitions.entities.entity-definition.fields.${name}.title`;
+const PLUGIN_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.pluginDefinition.name}`;
+const ENTITY_DEFINITION_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.entityDefinition.name}`;
+const MODULE_DEFINITION_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.moduleDefinition.name}`;
+const PROPERTIES_DATASOURCE = "{{ context.eval('properties') || [] }}";
+const GROUPS_DATASOURCE = "{{ context.eval('groups') || [] }}";
+//#endregion
+//#region ----- Layout helpers -----
+function gridRow(children) {
+    return {
+        type: AXPWidgetsList.Layouts.GridLayout,
+        mode: 'edit',
+        options: {
+            grid: {
+                default: { columns: 12, gap: '0.75rem' },
+            },
+        },
+        children,
+    };
+}
+function gridItem(colSpan, child) {
+    return {
+        type: AXPWidgetsList.Layouts.GridItemLayout,
+        mode: 'edit',
+        options: { colSpan },
+        children: [child],
+    };
+}
+function formField(label, editor) {
+    return {
+        type: AXPWidgetsList.Layouts.FormField,
+        mode: 'edit',
+        options: { label, showLabel: true },
+        children: [editor],
+    };
+}
+function textEditor(path, required = false) {
+    return {
+        type: AXPWidgetsList.Editors.TextBox,
+        mode: 'edit',
+        path,
+        name: path,
+        options: required ? { required: true } : {},
+    };
+}
+function largeTextEditor(path, rows = 2) {
+    return {
+        type: AXPWidgetsList.Editors.LargeTextBox,
+        mode: 'edit',
+        path,
+        name: path,
+        options: { rows },
+    };
+}
+function toggleEditor(path) {
+    return {
+        type: AXPWidgetsList.Editors.ToggleSwitch,
+        mode: 'edit',
+        path,
+        name: path,
+    };
+}
+function numberEditor(path, defaultValue) {
+    return {
+        type: AXPWidgetsList.Editors.NumberBox,
+        mode: 'edit',
+        path,
+        name: path,
+        options: defaultValue == null ? {} : { defaultValue },
+    };
+}
+function iconEditor(path) {
+    return {
+        type: AXPWidgetsList.Theme.IconChooser,
+        mode: 'edit',
+        path,
+        name: path,
+    };
+}
+function codeEditor(path, height = 'h-32') {
+    return {
+        type: AXPWidgetsList.Advanced.CodeEditor,
+        mode: 'edit',
+        path,
+        name: path,
+        options: { language: 'json', height },
+    };
+}
+function selectEditor(path, options) {
+    return {
+        type: AXPWidgetsList.Editors.SelectBox,
+        mode: 'edit',
+        path,
+        name: path,
+        options: {
+            valueField: options.valueField,
+            textField: options.textField,
+            dataSource: options.dataSource,
+            allowSearch: options.allowSearch ?? true,
+            required: options.required ?? false,
+        },
+    };
+}
+function lookupEditor(path, options) {
+    return {
+        type: AXPWidgetsList.Editors.LookupBox,
+        mode: 'edit',
+        path,
+        name: path,
+        options: {
+            entity: options.entity,
+            valueField: options.valueField,
+            textField: options.textField,
+            look: 'select',
+            allowSearch: true,
+            columns: options.columns,
+        },
+    };
+}
+//#endregion
+//#region ----- Repeater children -----
+const PLUGIN_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(6, formField(field('plugin-name'), lookupEditor('name', {
+            entity: PLUGIN_ENTITY,
+            valueField: 'name',
+            textField: 'catalogTitle',
+            columns: ['catalogTitle', 'name'],
+        }))),
+        gridItem(6, formField(field('plugin-options'), codeEditor('options'))),
+    ]),
+];
+const GROUP_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(4, formField(field('group-id'), textEditor('id', true))),
+        gridItem(5, formField(field('group-title'), textEditor('title', true))),
+        gridItem(3, formField(field('group-icon'), iconEditor('icon'))),
+        gridItem(12, formField(field('group-description'), largeTextEditor('description', 2))),
+    ]),
+];
+const PROPERTY_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(4, formField('@general:terms.common.name', textEditor('name', true))),
+        gridItem(4, formField('@general:terms.common.title', textEditor('title', true))),
+        gridItem(4, formField(field('group-id'), selectEditor('groupId', {
+            dataSource: GROUPS_DATASOURCE,
+            valueField: 'id',
+            textField: 'title',
+        }))),
+        gridItem(12, formField('@general:terms.common.description', largeTextEditor('description', 2))),
+        gridItem(12, formField(field('property-interface'), {
+            type: AXPWidgetsList.Advanced.WidgetFieldConfigurator,
+            mode: 'edit',
+            path: 'interface',
+            name: 'interface',
+            options: {
+                fieldName: "{{ context.eval('name') }}",
+                fieldTitle: "{{ context.eval('title') }}",
+            },
+        })),
+        gridItem(3, formField(field('property-data-type'), selectEditor('dataType', {
+            dataSource: [
+                { value: 'string', text: field('data-type-string') },
+                { value: 'number', text: field('data-type-number') },
+                { value: 'boolean', text: field('data-type-boolean') },
+                { value: 'date', text: field('data-type-date') },
+                { value: 'uuid', text: field('data-type-uuid') },
+                { value: 'object', text: field('data-type-object') },
+                { value: 'array', text: field('data-type-array') },
+            ],
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+        gridItem(3, formField(field('property-required'), toggleEditor('required'))),
+        gridItem(3, formField(field('property-nullable'), toggleEditor('nullable'))),
+        gridItem(3, formField(field('property-readonly'), toggleEditor('readonly'))),
+        gridItem(3, formField(field('property-unique'), toggleEditor('unique'))),
+        gridItem(3, formField(field('property-visible'), toggleEditor('visible'))),
+        gridItem(9, formField(field('property-default-value'), textEditor('defaultValue'))),
+    ]),
+];
+const COLUMN_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(4, formField(field('column-name'), selectEditor('name', {
+            dataSource: PROPERTIES_DATASOURCE,
+            valueField: 'name',
+            textField: 'title',
+            required: true,
+        }))),
+        gridItem(4, formField('@general:terms.common.title', textEditor('title'))),
+        gridItem(4, formField(field('column-widget'), selectEditor('widgetType', {
+            dataSource: 'PlatformManagement:ListEditorWidgets',
+            valueField: 'name',
+            textField: 'title',
+        }))),
+    ]),
+];
+const RELATED_ENTITY_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(6, formField(field('related-entity'), lookupEditor('entity', {
+            entity: ENTITY_DEFINITION_ENTITY,
+            valueField: 'name',
+            textField: 'name',
+            columns: ['name'],
+        }))),
+        gridItem(4, formField('@general:terms.common.title', textEditor('title'))),
+        gridItem(2, formField('@general:terms.common.icon', iconEditor('icon'))),
+        gridItem(4, formField(field('related-layout-type'), selectEditor('layoutType', {
+            dataSource: [
+                { value: 'page-list', text: field('layout-type-page-list') },
+                { value: 'tab-list', text: field('layout-type-tab-list') },
+                { value: 'merge-detail', text: field('layout-type-merge-detail') },
+                { value: 'page-detail', text: field('layout-type-page-detail') },
+                { value: 'tab-detail', text: field('layout-type-tab-detail') },
+            ],
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+        gridItem(4, formField(field('related-persistence-strategy'), selectEditor('persistenceStrategy', {
+            dataSource: [
+                { value: 'referenced', text: field('persistence-referenced') },
+                { value: 'embedded', text: field('persistence-embedded') },
+            ],
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+        gridItem(4, formField(field('related-foreign-key'), textEditor('foreignKeyField'))),
+        gridItem(4, formField(field('related-data-path'), textEditor('dataPath'))),
+        gridItem(4, formField(field('related-id-field'), textEditor('idField'))),
+        gridItem(2, formField(field('appear-on-create'), toggleEditor('appearOnCreate'))),
+        gridItem(2, formField(field('appear-on-update'), toggleEditor('appearOnUpdate'))),
+    ]),
+];
+const CREATE_SECTION_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(12, formField(field('section-id'), selectEditor('id', {
+            dataSource: GROUPS_DATASOURCE,
+            valueField: 'id',
+            textField: 'title',
+            required: true,
+        }))),
+    ]),
+];
+const CREATE_PROPERTY_LAYOUT_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(8, formField(field('layout-property-name'), selectEditor('name', {
+            dataSource: PROPERTIES_DATASOURCE,
+            valueField: 'name',
+            textField: 'title',
+            required: true,
+        }))),
+        gridItem(4, formField(field('layout-col-span'), numberEditor('colSpan', 6))),
+    ]),
+];
+const ACTION_COMMAND_DATASOURCE = [
+    { value: ENTITY_CREATE_UI, text: '@general:actions.create.title' },
+    { value: 'Entity:OpenDetails', text: '@general:actions.view.title' },
+    { value: ENTITY_EDIT_UI, text: '@general:actions.edit.title' },
+    { value: ENTITY_REMOVE_UI, text: '@general:actions.delete.title' },
+];
+const ACTION_TYPE_DATASOURCE = [
+    { value: 'create', text: '@general:actions.create.title' },
+    { value: 'view', text: '@general:actions.view.title' },
+    { value: 'update', text: '@general:actions.edit.title' },
+    { value: 'delete', text: '@general:actions.delete.title' },
+];
+const ACTION_PRIORITY_DATASOURCE = [
+    { value: 'primary', text: field('priority-primary') },
+    { value: 'secondary', text: field('priority-secondary') },
+    { value: 'none', text: field('priority-none') },
+];
+const ACTION_SCOPE_DATASOURCE = [
+    { value: 'typeLevel', text: field('scope-type-level') },
+    { value: 'individual', text: field('scope-individual') },
+    { value: 'selected', text: field('scope-selected') },
+];
+const ACTION_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(4, formField('@general:terms.common.title', textEditor('title', true))),
+        gridItem(4, formField(field('action-command'), selectEditor('command', {
+            dataSource: ACTION_COMMAND_DATASOURCE,
+            valueField: 'value',
+            textField: 'text',
+            required: true,
+        }))),
+        gridItem(4, formField(field('action-icon'), iconEditor('icon'))),
+        gridItem(4, formField(field('action-type'), selectEditor('type', {
+            dataSource: ACTION_TYPE_DATASOURCE,
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+        gridItem(4, formField(field('action-priority'), selectEditor('priority', {
+            dataSource: ACTION_PRIORITY_DATASOURCE,
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+        gridItem(4, formField(field('action-scope'), selectEditor('scope', {
+            dataSource: ACTION_SCOPE_DATASOURCE,
+            valueField: 'value',
+            textField: 'text',
+            allowSearch: false,
+        }))),
+    ]),
+];
+const PAGE_REPEATER_CHILDREN = [
+    gridRow([
+        gridItem(4, formField(field('page-component-key'), textEditor('componentKey', true))),
+        gridItem(4, formField('@general:terms.common.title', textEditor('title'))),
+        gridItem(4, formField('@general:terms.common.icon', iconEditor('icon'))),
+        gridItem(4, formField(field('page-field'), textEditor('field'))),
+        gridItem(4, formField(field('page-order'), numberEditor('order', 1))),
+        gridItem(2, formField(field('appear-on-create'), toggleEditor('appearOnCreate'))),
+        gridItem(2, formField(field('appear-on-update'), toggleEditor('appearOnUpdate'))),
+    ]),
+];
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const i18n = RootConfig.config.i18n;
+const ENTITY_DEFINITION_CREATE_ERROR = {
+    nameRequired: `@${i18n}:entity-definitions.messages.name-required`,
+    moduleRequired: `@${i18n}:entity-definitions.messages.module-required`,
+    nameInvalid: `@${i18n}:entity-definitions.messages.name-invalid`,
+    nameDuplicate: `@${i18n}:entity-definitions.messages.name-duplicate`,
+};
+const ENTITY_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+const DEFAULT_ENTITY_ICON = 'fa-light fa-cube';
+const WIDGET_DATA_TYPE = {
+    'number-editor': 'number',
+    'number-unit-editor': 'number',
+    'toggle-editor': 'boolean',
+    'checkbox-editor': 'boolean',
+    'date-time-editor': 'date',
+    'repeater-layout': 'array',
+    'tag-editor': 'array',
+    'lookup-editor': 'uuid',
+    'contact-editor': 'object',
+    attachments: 'array',
+    'widget-field-configurator': 'object',
+};
+//#endregion
+//#region ----- Assemble store row -----
+/**
+ * Turns a create/update-form payload into the EntityDefinition store shape
+ * `{ name: Module.Entity, content: AXPEntity }`.
+ */
+function assembleEntityDefinitionStoreRecord(input, previous) {
+    const merged = { ...(previous ?? {}), ...input };
+    const previousContent = readContent(previous ?? {}) ?? readContent(merged);
+    const moduleName = readTrimmed(merged['module']) || readTrimmed(previousContent?.['module']);
+    const rawName = readTrimmed(merged['name']) || readTrimmed(previousContent?.['name']);
+    const title = readTrimmed(merged['title']) ||
+        readTrimmed(previousContent?.['title']) ||
+        rawName;
+    const icon = readTrimmed(merged['icon']) ||
+        readTrimmed(previousContent?.['icon']) ||
+        DEFAULT_ENTITY_ICON;
+    if (!rawName) {
+        return {
+            ok: false,
+            message: ENTITY_DEFINITION_CREATE_ERROR.nameRequired,
+            code: 'ENTITY_DEFINITION_NAME_REQUIRED',
+        };
+    }
+    if (!moduleName) {
+        return {
+            ok: false,
+            message: ENTITY_DEFINITION_CREATE_ERROR.moduleRequired,
+            code: 'ENTITY_DEFINITION_MODULE_REQUIRED',
+        };
+    }
+    const parsed = parseEntityName(rawName, moduleName);
+    if (!ENTITY_NAME_PATTERN.test(parsed.entityName)) {
+        return {
+            ok: false,
+            message: ENTITY_DEFINITION_CREATE_ERROR.nameInvalid,
+            code: 'ENTITY_DEFINITION_NAME_INVALID',
+        };
+    }
+    const identity = {
+        module: parsed.moduleName,
+        name: parsed.entityName,
+        title: title || parsed.entityName,
+        icon,
+    };
+    const content = overlayDesignerFields(previousContent ?? buildStubEntityContent(identity), merged, identity);
+    const record = omitDesignerFormFields(merged);
+    record['name'] = parsed.storeName;
+    record['content'] = content;
+    return { ok: true, record };
+}
+//#endregion
+//#region ----- Overlay designer fields -----
+function overlayDesignerFields(existing, input, identity) {
+    const groups = readArray(input['groups']);
+    const propertyRows = readArray(input['properties']);
+    const pluginRows = input['plugins'] !== undefined ? readArray(input['plugins']) : undefined;
+    const columnRows = input['columns'] !== undefined ? readArray(input['columns']) : undefined;
+    const relatedRows = input['relatedEntities'] !== undefined ? readArray(input['relatedEntities']) : undefined;
+    const createSections = input['createSections'] !== undefined ? readArray(input['createSections']) : undefined;
+    const createProperties = input['createProperties'] !== undefined ? readArray(input['createProperties']) : undefined;
+    const listActions = input['listActions'] !== undefined ? readArray(input['listActions']) : undefined;
+    const singleActions = input['singleActions'] !== undefined ? readArray(input['singleActions']) : undefined;
+    const pages = input['pages'] !== undefined ? readArray(input['pages']) : undefined;
+    const mappedGroups = groups.length
+        ? groups.map(mapGroup)
+        : readExistingArray(existing['groups']);
+    const mappedProperties = propertyRows.length
+        ? propertyRows.map((row) => mapProperty(row, mappedGroups))
+        : readExistingArray(existing['properties']);
+    const content = {
+        ...existing,
+        module: identity.module,
+        name: identity.name,
+        title: identity.title,
+        icon: identity.icon,
+    };
+    const parentKey = readTrimmed(input['parentKey']);
+    if (parentKey) {
+        content['parentKey'] = parentKey;
+    }
+    else if (input['parentKey'] !== undefined) {
+        delete content['parentKey'];
+    }
+    const searchTags = input['searchTags'];
+    if (searchTags !== undefined) {
+        content['searchTags'] = Array.isArray(searchTags)
+            ? searchTags.filter((tag) => typeof tag === 'string' && tag.trim())
+            : [];
+    }
+    overlayFormats(content, input, identity.title);
+    overlayCategory(content, input);
+    if (pluginRows) {
+        content['plugins'] = pluginRows.map(mapPlugin).filter((plugin) => plugin.name);
+    }
+    if (mappedGroups.length) {
+        content['groups'] = mappedGroups;
+    }
+    if (mappedProperties.length) {
+        content['properties'] = mappedProperties;
+    }
+    const resolvedProperties = content['properties'] ?? [];
+    if (columnRows) {
+        content['columns'] = columnRows.length
+            ? columnRows.map((row) => mapColumn(row, resolvedProperties))
+            : defaultColumns(resolvedProperties);
+    }
+    else if (!Array.isArray(existing['columns']) && resolvedProperties.length) {
+        content['columns'] = defaultColumns(resolvedProperties);
+    }
+    if (relatedRows) {
+        content['relatedEntities'] = relatedRows.map(mapRelatedEntity).filter((row) => row.entity);
+    }
+    const schemaChanged = groups.length > 0 || propertyRows.length > 0;
+    const layoutExplicit = createSections !== undefined || createProperties !== undefined;
+    const actionsExplicit = listActions !== undefined || singleActions !== undefined;
+    if (schemaChanged || layoutExplicit || actionsExplicit) {
+        overlayInterfaces(content, {
+            groups: content['groups'] ?? [],
+            properties: resolvedProperties,
+            createSections,
+            createProperties,
+            listActions,
+            singleActions,
+            schemaChanged,
+            layoutExplicit,
+        });
+    }
+    if (pages) {
+        content['pages'] = pages.map(mapPage).filter((page) => page['componentKey']);
+    }
+    overlayJsonKey(content, input, 'rules', 'rules');
+    overlayJsonKey(content, input, 'validations', 'validations');
+    overlayJsonKey(content, input, 'commandsJson', 'commands');
+    overlayJsonKey(content, input, 'queriesJson', 'queries');
+    return content;
+}
+function overlayFormats(content, input, fallbackTitle) {
+    const current = content['formats'] ?? {};
+    const individual = readTrimmed(input['formatIndividual']) || String(current['individual'] ?? fallbackTitle);
+    const plural = readTrimmed(input['formatPlural']) || String(current['plural'] ?? fallbackTitle);
+    const displayName = readTrimmed(input['formatDisplayName']) ||
+        (typeof current['displayName'] === 'string' ? current['displayName'] : undefined);
+    const searchTitle = readTrimmed(input['formatSearchTitle']) ||
+        String(current['searchResult']?.['title'] ?? '{{ name }}');
+    const searchDescription = readTrimmed(input['formatSearchDescription']) ||
+        String(current['searchResult']?.['description'] ??
+            String(content['module'] ?? ''));
+    content['formats'] = {
+        ...current,
+        individual,
+        plural,
+        ...(displayName ? { displayName } : {}),
+        searchResult: {
+            title: searchTitle,
+            description: searchDescription,
+        },
+    };
+}
+function overlayCategory(content, input) {
+    const entityName = readTrimmed(input['categoryEntity']);
+    if (!entityName) {
+        if (input['categoryEntity'] !== undefined) {
+            delete content['category'];
+        }
+        return;
+    }
+    content['category'] = {
+        entity: entityName,
+        textField: readTrimmed(input['categoryTextField']) || 'title',
+        valueField: readTrimmed(input['categoryValueField']) || 'id',
+    };
+}
+function overlayInterfaces(content, args) {
+    const existing = content['interfaces'] ?? {};
+    const master = existing['master'] ?? {};
+    const existingList = master['list'] ?? {};
+    const existingCreate = master['create'] ?? {};
+    const existingSingle = master['single'] ?? {};
+    let sections = existingCreate['sections'];
+    let propertyLayouts = existingCreate['properties'];
+    if (args.layoutExplicit || args.schemaChanged) {
+        const sectionIds = resolveSectionIds(args.createSections, args.groups);
+        sections = sectionIds.map((id) => ({
+            id,
+            layout: { positions: { lg: { colSpan: 12 } } },
+        }));
+        propertyLayouts = resolvePropertyLayouts(args.createProperties, args.properties);
+    }
+    const listActions = args.listActions
+        ? args.listActions.map(mapAction).filter((action) => action.command)
+        : (existingList['actions'] ?? [...entityMasterCrudActions()]);
+    const singleActions = args.singleActions
+        ? args.singleActions.map(mapAction).filter((action) => action.command)
+        : (existingSingle['actions'] ?? [...entityMasterRecordActions()]);
+    content['interfaces'] = {
+        ...existing,
+        master: {
+            ...master,
+            list: {
+                ...existingList,
+                views: existingList['views'] ?? [createAllQueryView({ sorts: [{ name: 'name', dir: 'asc' }] })],
+                actions: listActions.length ? listActions : [...entityMasterCrudActions()],
+            },
+            create: {
+                ...existingCreate,
+                sections,
+                properties: propertyLayouts,
+            },
+            update: {
+                ...(master['update'] ?? {}),
+                sections,
+                properties: propertyLayouts,
+            },
+            single: {
+                ...existingSingle,
+                title: String(existingSingle['title'] ?? '{{ title || name }}') || '{{ title || name }}',
+                sections,
+                properties: propertyLayouts,
+                actions: singleActions.length ? singleActions : [...entityMasterRecordActions()],
+            },
+        },
+    };
+}
+function overlayJsonKey(content, input, formKey, contentKey) {
+    if (input[formKey] === undefined) {
+        return;
+    }
+    const parsed = parseJsonValue(input[formKey]);
+    if (parsed === undefined) {
+        return;
+    }
+    content[contentKey] = parsed;
+}
+//#endregion
+//#region ----- Row mappers -----
+function mapGroup(row) {
+    const id = readTrimmed(row['id']);
+    return {
+        id,
+        title: readTrimmed(row['title']) || id,
+        ...(readTrimmed(row['description']) ? { description: readTrimmed(row['description']) } : {}),
+        ...(readTrimmed(row['icon']) ? { icon: readTrimmed(row['icon']) } : {}),
+    };
+}
+function mapProperty(row, groups) {
+    const name = readTrimmed(row['name']);
+    const widget = mapWidgetInterface(row['interface']);
+    const dataType = readTrimmed(row['dataType']) || inferDataType(widget?.type) || 'string';
+    const required = row['required'] === true;
+    const unique = row['unique'] === true;
+    const groupId = readTrimmed(row['groupId']) || groups[0]?.id || 'basic-info';
+    const defaultValue = row['defaultValue'];
+    return {
+        name,
+        title: readTrimmed(row['title']) || name,
+        ...(readTrimmed(row['description']) ? { description: readTrimmed(row['description']) } : {}),
+        groupId,
+        schema: {
+            dataType,
+            ...(row['nullable'] === true ? { nullable: true } : {}),
+            ...(row['readonly'] === true ? { readonly: true } : {}),
+            ...(row['visible'] === false ? { visible: false } : {}),
+            ...(defaultValue !== undefined && defaultValue !== '' ? { defaultValue } : {}),
+            ...(unique ? { unique: { enabled: true } } : {}),
+            ...(widget ? { interface: widget } : { interface: { type: AXPWidgetsCatalog.text } }),
+        },
+        ...(required ? { validations: [{ rule: 'required' }] } : {}),
+        options: {
+            filter: { inline: { enabled: true }, advance: { enabled: true } },
+            sort: { enabled: true },
+        },
+    };
+}
+function mapWidgetInterface(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const node = value;
+    const type = readTrimmed(node['type']);
+    if (!type) {
+        return null;
+    }
+    const mapped = { type };
+    if (node['options'] && typeof node['options'] === 'object' && !Array.isArray(node['options'])) {
+        mapped.options = node['options'];
+    }
+    if (Array.isArray(node['children'])) {
+        mapped.children = node['children'];
+    }
+    if (node['mode'] === 'view' || node['mode'] === 'edit') {
+        mapped.mode = node['mode'];
+    }
+    return mapped;
+}
+function inferDataType(widgetType) {
+    if (!widgetType) {
+        return undefined;
+    }
+    return WIDGET_DATA_TYPE[widgetType];
+}
+function mapPlugin(row) {
+    if (typeof row === 'string') {
+        return { name: row.trim() };
+    }
+    if (!row || typeof row !== 'object' || Array.isArray(row)) {
+        return { name: '' };
+    }
+    const record = row;
+    const name = readTrimmed(record['name']);
+    const options = parseJsonValue(record['options']);
+    if (options && typeof options === 'object' && !Array.isArray(options)) {
+        return { name, options: options };
+    }
+    return { name };
+}
+function mapColumn(row, properties) {
+    const name = readTrimmed(row['name']);
+    const property = properties.find((item) => item.name === name);
+    const title = readTrimmed(row['title']) || property?.title || name;
+    const widgetType = readTrimmed(row['widgetType']) ||
+        String(property?.schema?.interface?.type ?? AXPWidgetsCatalog.text);
+    return {
+        name,
+        title,
+        showAs: { type: widgetType },
+    };
+}
+function defaultColumns(properties) {
+    return properties
+        .filter((property) => property.schema?.visible !== false)
+        .slice(0, 6)
+        .map((property) => ({
+        name: property.name,
+        title: property.title,
+        showAs: { type: property.schema?.interface?.type || AXPWidgetsCatalog.text },
+    }));
+}
+function mapRelatedEntity(row) {
+    const layoutType = readTrimmed(row['layoutType']) || 'page-list';
+    const related = {
+        entity: readTrimmed(row['entity']),
+        ...(readTrimmed(row['title']) ? { title: readTrimmed(row['title']) } : {}),
+        ...(readTrimmed(row['icon']) ? { icon: readTrimmed(row['icon']) } : {}),
+        layout: {
+            type: layoutType,
+            position: 'after',
+        },
+    };
+    const persistence = {};
+    const foreignKey = readTrimmed(row['foreignKeyField']);
+    const dataPath = readTrimmed(row['dataPath']);
+    const idField = readTrimmed(row['idField']);
+    const strategy = readTrimmed(row['persistenceStrategy']);
+    if (foreignKey) {
+        persistence.foreignKeyField = foreignKey;
+    }
+    if (dataPath) {
+        persistence.dataPath = dataPath;
+    }
+    if (idField) {
+        persistence.idField = idField;
+    }
+    if (strategy === 'embedded' || strategy === 'referenced') {
+        persistence.strategy = strategy;
+    }
+    if (Object.keys(persistence).length) {
+        related.persistence = persistence;
+    }
+    if (row['appearOnCreate'] === true || row['appearOnUpdate'] === true) {
+        related.appearOn = {
+            ...(row['appearOnCreate'] === true ? { create: true } : {}),
+            ...(row['appearOnUpdate'] === true ? { update: true } : {}),
+        };
+    }
+    return related;
+}
+function mapAction(row) {
+    const command = readTrimmed(row['command']);
+    return {
+        title: readTrimmed(row['title']) || command,
+        command,
+        type: (readTrimmed(row['type']) || 'view'),
+        priority: (readTrimmed(row['priority']) || 'secondary'),
+        scope: (readTrimmed(row['scope']) || 'individual'),
+        ...(readTrimmed(row['icon']) ? { icon: readTrimmed(row['icon']) } : {}),
+    };
+}
+function mapPage(row) {
+    const order = Number(row['order']);
+    return {
+        componentKey: readTrimmed(row['componentKey']),
+        ...(readTrimmed(row['title']) ? { title: readTrimmed(row['title']) } : {}),
+        ...(readTrimmed(row['icon']) ? { icon: readTrimmed(row['icon']) } : {}),
+        ...(readTrimmed(row['field']) ? { field: readTrimmed(row['field']) } : {}),
+        ...(Number.isFinite(order) ? { layout: { order, position: 'after' } } : {}),
+        ...(row['appearOnCreate'] === true || row['appearOnUpdate'] === true
+            ? {
+                appearOn: {
+                    ...(row['appearOnCreate'] === true ? { create: true } : {}),
+                    ...(row['appearOnUpdate'] === true ? { update: true } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function resolveSectionIds(createSections, groups) {
+    if (createSections?.length) {
+        return createSections.map((row) => readTrimmed(row['id'])).filter(Boolean);
+    }
+    if (groups.length) {
+        return groups.map((group) => group.id);
+    }
+    return ['basic-info'];
+}
+function resolvePropertyLayouts(createProperties, properties) {
+    const source = createProperties?.length
+        ? createProperties
+        : properties
+            .filter((property) => property.schema?.visible !== false)
+            .map((property) => ({ name: property.name, colSpan: 6 }));
+    return source
+        .map((row) => {
+        const name = readTrimmed(row['name']);
+        const colSpan = Number(row['colSpan']);
+        return {
+            name,
+            layout: {
+                positions: { lg: { colSpan: Number.isFinite(colSpan) && colSpan > 0 ? colSpan : 6 } },
+            },
+        };
+    })
+        .filter((row) => row.name);
+}
+//#endregion
+//#region ----- Stub content -----
+function buildStubEntityContent(identity) {
+    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
+    const propertyLayouts = [
+        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+    ];
+    const stub = {
+        module: identity.module,
+        name: identity.name,
+        title: identity.title,
+        icon: identity.icon,
+        plugins: [],
+        formats: {
+            individual: identity.title,
+            plural: identity.title,
+            searchResult: {
+                title: '{{ name }}',
+                description: identity.module,
+            },
+        },
+        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
+        properties: [
+            {
+                name: 'name',
+                title: '@general:terms.common.name',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+                validations: [{ rule: 'required' }],
+            },
+        ],
+        columns: [
+            { name: 'name', title: '@general:terms.common.name', showAs: { type: AXPWidgetsCatalog.text } },
+            { name: 'title', title: '@general:terms.common.title', showAs: { type: AXPWidgetsCatalog.text } },
+        ],
+        interfaces: {
+            master: {
+                list: {
+                    views: [createAllQueryView({ sorts: [{ name: 'name', dir: 'asc' }] })],
+                    actions: [...entityMasterCrudActions()],
+                },
+                create: {
+                    sections,
+                    properties: propertyLayouts,
+                },
+                single: {
+                    title: '{{ title || name }}',
+                    sections,
+                    properties: propertyLayouts,
+                    actions: [...entityMasterRecordActions()],
+                },
+            },
+        },
+    };
+    return stub;
+}
+function parseEntityName(rawName, moduleName) {
+    if (!rawName.includes('.')) {
+        return {
+            moduleName,
+            entityName: rawName,
+            storeName: `${moduleName}.${rawName}`,
+        };
+    }
+    const lastDot = rawName.lastIndexOf('.');
+    const maybeModule = rawName.slice(0, lastDot).trim();
+    const entityName = rawName.slice(lastDot + 1).trim();
+    const resolvedModule = moduleName || maybeModule;
+    return {
+        moduleName: resolvedModule,
+        entityName,
+        storeName: `${resolvedModule}.${entityName}`,
+    };
+}
+function readContent(input) {
+    const value = input['content'];
+    if (typeof value === 'string' && value.trim()) {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function omitDesignerFormFields(input) {
+    const next = { ...input };
+    for (const key of ENTITY_DEFINITION_DESIGNER_FORM_KEYS) {
+        delete next[key];
+    }
+    return next;
+}
+function readArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => item && typeof item === 'object' && !Array.isArray(item));
+}
+function readExistingArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function parseJsonValue(value) {
+    if (value == null || value === '') {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return value;
+}
+function readTrimmed(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+//#endregion
+//#region ----- Flatten content to designer form -----
+/**
+ * Maps stored `AXPEntity` content back onto the wizard form fields
+ * (repeaters, JSON editors, identity extras).
+ */
+function flattenEntityContentToDesignerForm(content) {
+    if (!content) {
+        return {};
+    }
+    const formats = asRecord(content['formats']);
+    const searchResult = asRecord(formats['searchResult']);
+    const category = asRecord(content['category']);
+    const interfaces = asRecord(content['interfaces']);
+    const master = asRecord(interfaces['master']);
+    const create = asRecord(master['create']);
+    const list = asRecord(master['list']);
+    const single = asRecord(master['single']);
+    return {
+        parentKey: readTrimmed(content['parentKey']),
+        searchTags: Array.isArray(content['searchTags']) ? content['searchTags'] : [],
+        formatIndividual: readTrimmed(formats['individual']),
+        formatPlural: readTrimmed(formats['plural']),
+        formatDisplayName: readTrimmed(formats['displayName']),
+        formatSearchTitle: readTrimmed(searchResult['title']),
+        formatSearchDescription: readTrimmed(searchResult['description']),
+        categoryEntity: readTrimmed(category['entity']),
+        categoryTextField: readTrimmed(category['textField']) || 'title',
+        categoryValueField: readTrimmed(category['valueField']) || 'id',
+        plugins: flattenPlugins(content['plugins']),
+        groups: readArray(content['groups']),
+        properties: flattenProperties(content['properties']),
+        columns: flattenColumns(content['columns']),
+        relatedEntities: flattenRelatedEntities(content['relatedEntities']),
+        createSections: flattenSections(create['sections']),
+        createProperties: flattenPropertyLayouts(create['properties']),
+        listActions: flattenActions(list['actions']),
+        singleActions: flattenActions(single['actions']),
+        pages: flattenPages(content['pages']),
+        rules: stringifyJson(content['rules']),
+        validations: stringifyJson(content['validations']),
+        commandsJson: stringifyJson(content['commands']),
+        queriesJson: stringifyJson(content['queries']),
+    };
+}
+function flattenProperties(value) {
+    return readArray(value).map((row) => {
+        const schema = asRecord(row['schema']);
+        if (!Object.keys(schema).length) {
+            return row;
+        }
+        const unique = asRecord(schema['unique']);
+        const validations = Array.isArray(row['validations']) ? row['validations'] : [];
+        const required = validations.some((item) => item && typeof item === 'object' && item['rule'] === 'required');
+        return {
+            name: readTrimmed(row['name']),
+            title: readTrimmed(row['title']) || readTrimmed(row['name']),
+            description: readTrimmed(row['description']),
+            groupId: readTrimmed(row['groupId']),
+            interface: schema['interface'] ?? { type: AXPWidgetsCatalog.text },
+            dataType: readTrimmed(schema['dataType']) || 'string',
+            required,
+            nullable: schema['nullable'] === true,
+            readonly: schema['readonly'] === true,
+            unique: unique['enabled'] === true,
+            visible: schema['visible'] !== false,
+            defaultValue: schema['defaultValue'] ?? '',
+        };
+    });
+}
+function flattenPlugins(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const rows = [];
+    for (const item of value) {
+        if (typeof item === 'string') {
+            const name = item.trim();
+            if (name) {
+                rows.push({ name, options: '' });
+            }
+            continue;
+        }
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const row = item;
+        const name = readTrimmed(row['name']);
+        if (!name) {
+            continue;
+        }
+        rows.push({
+            name,
+            options: stringifyJson(row['options']),
+        });
+    }
+    return rows;
+}
+function flattenColumns(value) {
+    return readArray(value).map((row) => {
+        const showAs = asRecord(row['showAs']);
+        return {
+            name: readTrimmed(row['name']),
+            title: readTrimmed(row['title']),
+            widgetType: readTrimmed(row['widgetType']) || readTrimmed(showAs['type']),
+        };
+    });
+}
+function flattenRelatedEntities(value) {
+    return readArray(value).map((row) => {
+        const layout = asRecord(row['layout']);
+        const persistence = asRecord(row['persistence']);
+        const appearOn = asRecord(row['appearOn']);
+        return {
+            entity: readTrimmed(row['entity']),
+            title: readTrimmed(row['title']),
+            icon: readTrimmed(row['icon']),
+            layoutType: readTrimmed(layout['type']) || 'page-list',
+            foreignKeyField: readTrimmed(persistence['foreignKeyField']),
+            dataPath: readTrimmed(persistence['dataPath']),
+            idField: readTrimmed(persistence['idField']),
+            persistenceStrategy: readTrimmed(persistence['strategy']),
+            appearOnCreate: appearOn['create'] === true,
+            appearOnUpdate: appearOn['update'] === true,
+        };
+    });
+}
+function flattenSections(value) {
+    return readArray(value).map((row) => ({ id: readTrimmed(row['id']) })).filter((row) => row.id);
+}
+function flattenPropertyLayouts(value) {
+    return readArray(value).map((row) => {
+        const layout = asRecord(row['layout']);
+        const positions = asRecord(layout['positions']);
+        const lg = asRecord(positions['lg']);
+        const colSpan = Number(lg['colSpan']);
+        return {
+            name: readTrimmed(row['name']),
+            colSpan: Number.isFinite(colSpan) && colSpan > 0 ? colSpan : 6,
+        };
+    });
+}
+function flattenActions(value) {
+    return readArray(value).map((row) => {
+        const command = row['command'];
+        const commandName = typeof command === 'string'
+            ? command
+            : command && typeof command === 'object' && !Array.isArray(command)
+                ? readTrimmed(command['name'])
+                : '';
+        return {
+            title: readTrimmed(row['title']),
+            command: commandName,
+            icon: readTrimmed(row['icon']),
+            type: readTrimmed(row['type']) || 'view',
+            priority: readTrimmed(row['priority']) || 'secondary',
+            scope: readTrimmed(row['scope']) || 'individual',
+        };
+    });
+}
+function flattenPages(value) {
+    return readArray(value).map((row) => {
+        const appearOn = asRecord(row['appearOn']);
+        const layout = asRecord(row['layout']);
+        return {
+            componentKey: readTrimmed(row['componentKey']),
+            title: readTrimmed(row['title']),
+            icon: readTrimmed(row['icon']),
+            field: readTrimmed(row['field']),
+            order: layout['order'] ?? '',
+            appearOnCreate: appearOn['create'] === true,
+            appearOnUpdate: appearOn['update'] === true,
+        };
+    });
+}
+function stringifyJson(value) {
+    if (value == null || value === '') {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return '';
+    }
+}
+function asRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const LIST_FILTER_SORT = {
+    filter: { inline: { enabled: true }, advance: { enabled: true } },
+    sort: { enabled: true },
+};
+const i18nScope = RootConfig.config.i18n;
+function fieldTitle(name) {
+    return `@${i18nScope}:entity-definitions.entities.entity-definition.fields.${name}.title`;
+}
+function groupTitle(name) {
+    return `@${i18nScope}:entity-definitions.entities.entity-definition.groups.${name}`;
+}
+function pageTitle(name) {
+    return `@${i18nScope}:entity-definitions.entities.entity-definition.pages.${name}.title`;
+}
+function repeaterProperty(name, groupId, children) {
+    return {
+        name,
+        title: fieldTitle(name),
+        groupId,
+        schema: {
+            dataType: 'array',
+            defaultValue: [],
+            interface: {
+                type: AXPWidgetsList.Layouts.RepeaterLayout,
+                options: { hasControls: true, allowReorder: true },
+                children: children,
+            },
+        },
+    };
+}
+//#endregion
+//#region ----- Entity -----
 function buildEntityDefinitionEntity() {
-    const i18n = RootConfig.config.i18n;
+    const identityLayout = [
+        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'module', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'icon', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'parentKey', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'searchTags', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'formatIndividual', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'formatPlural', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'formatDisplayName', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'formatSearchTitle', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'formatSearchDescription', layout: { positions: { lg: { colSpan: 12 } } } },
+        { name: 'categoryEntity', layout: { positions: { lg: { colSpan: 6 } } } },
+        { name: 'categoryTextField', layout: { positions: { lg: { colSpan: 3 } } } },
+        { name: 'categoryValueField', layout: { positions: { lg: { colSpan: 3 } } } },
+    ];
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.entityDefinition.name,
@@ -105,16 +1337,40 @@ function buildEntityDefinitionEntity() {
             },
         },
         plugins: [],
-        groups: [
+        pages: [
             {
-                id: 'basic-info',
-                title: `@${i18n}:entity-definitions.entities.entity-definition.groups.basic-info`,
+                componentKey: ENTITY_DEFINITION_SCHEMA_PAGE_COMPONENT_KEY,
+                field: 'properties',
+                title: pageTitle('schema'),
+                icon: 'fa-light fa-list',
+                layout: { order: 1, position: 'after' },
+                appearOn: { create: true, update: true },
+                options: { propertyNames: [...ENTITY_DEFINITION_SCHEMA_PROPERTY_NAMES] },
             },
             {
-                id: 'schema',
-                title: `@${i18n}:entity-definitions.entities.entity-definition.groups.schema`,
+                componentKey: ENTITY_DEFINITION_SURFACES_PAGE_COMPONENT_KEY,
+                field: 'interfaces',
+                title: pageTitle('surfaces'),
+                icon: 'fa-light fa-table-columns',
+                layout: { order: 2, position: 'after' },
+                appearOn: { create: true, update: true },
+                options: { propertyNames: [...ENTITY_DEFINITION_SURFACES_PROPERTY_NAMES] },
             },
         ],
+        groups: [
+            { id: 'basic-info', title: groupTitle('basic-info') },
+            { id: 'formats', title: groupTitle('formats') },
+            { id: 'category', title: groupTitle('category') },
+            { id: 'plugins', title: groupTitle('plugins') },
+            { id: 'groups', title: groupTitle('groups') },
+            { id: 'properties', title: groupTitle('properties') },
+            { id: 'columns', title: groupTitle('columns') },
+            { id: 'related-entities', title: groupTitle('related-entities') },
+            { id: 'layouts', title: groupTitle('layouts') },
+            { id: 'actions', title: groupTitle('actions') },
+            { id: 'advanced', title: groupTitle('advanced') },
+            { id: 'schema', title: groupTitle('schema') },
+        ],
         properties: [
             {
                 name: 'id',
@@ -133,27 +1389,31 @@ function buildEntityDefinitionEntity() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    readonly: true,
                     interface: { type: AXPWidgetsCatalog.text },
                 },
-                options: {
-                    filter: { inline: { enabled: true }, advance: { enabled: true } },
-                    sort: { enabled: true },
-                },
+                validations: [{ rule: 'required' }],
+                options: LIST_FILTER_SORT,
             },
             {
                 name: 'module',
-                title: `@${i18n}:entity-definitions.entities.entity-definition.fields.module-id.title`,
+                title: fieldTitle('module-id'),
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    readonly: true,
-                    interface: { type: AXPWidgetsCatalog.text },
-                },
-                options: {
-                    filter: { inline: { enabled: true }, advance: { enabled: true } },
-                    sort: { enabled: true },
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: MODULE_DEFINITION_ENTITY,
+                            textField: 'title',
+                            valueField: 'name',
+                            look: 'select',
+                            allowSearch: true,
+                            columns: ['title', 'name'],
+                        },
+                    },
                 },
+                validations: [{ rule: 'required' }],
+                options: LIST_FILTER_SORT,
             },
             {
                 name: 'title',
@@ -161,13 +1421,10 @@ function buildEntityDefinitionEntity() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    readonly: true,
                     interface: { type: AXPWidgetsCatalog.text },
                 },
-                options: {
-                    filter: { inline: { enabled: true }, advance: { enabled: true } },
-                    sort: { enabled: true },
-                },
+                validations: [{ rule: 'required' }],
+                options: LIST_FILTER_SORT,
             },
             {
                 name: 'icon',
@@ -175,13 +1432,199 @@ function buildEntityDefinitionEntity() {
                 groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
-                    readonly: true,
                     interface: { type: AXPWidgetsCatalog.iconChooser },
                 },
             },
+            {
+                name: 'parentKey',
+                title: fieldTitle('parent-key'),
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'searchTags',
+                title: fieldTitle('search-tags'),
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'array',
+                    defaultValue: [],
+                    interface: { type: AXPWidgetsList.Editors.TagEditor },
+                },
+            },
+            {
+                name: 'formatIndividual',
+                title: fieldTitle('format-individual'),
+                groupId: 'formats',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'formatPlural',
+                title: fieldTitle('format-plural'),
+                groupId: 'formats',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'formatDisplayName',
+                title: fieldTitle('format-display-name'),
+                groupId: 'formats',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'formatSearchTitle',
+                title: fieldTitle('format-search-title'),
+                groupId: 'formats',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'formatSearchDescription',
+                title: fieldTitle('format-search-description'),
+                groupId: 'formats',
+                schema: {
+                    dataType: 'string',
+                    interface: { type: AXPWidgetsCatalog.largeText, options: { rows: 2 } },
+                },
+            },
+            {
+                name: 'categoryEntity',
+                title: fieldTitle('category-entity'),
+                groupId: 'category',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.entityDefinition.name}`,
+                            textField: 'name',
+                            valueField: 'name',
+                            look: 'select',
+                            allowSearch: true,
+                            columns: ['name'],
+                        },
+                    },
+                },
+            },
+            {
+                name: 'categoryTextField',
+                title: fieldTitle('category-text-field'),
+                groupId: 'category',
+                schema: {
+                    dataType: 'string',
+                    defaultValue: 'title',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                name: 'categoryValueField',
+                title: fieldTitle('category-value-field'),
+                groupId: 'category',
+                schema: {
+                    dataType: 'string',
+                    defaultValue: 'id',
+                    interface: { type: AXPWidgetsCatalog.text },
+                },
+            },
+            {
+                ...repeaterProperty('plugins', 'plugins', PLUGIN_REPEATER_CHILDREN),
+            },
+            {
+                ...repeaterProperty('groups', 'groups', GROUP_REPEATER_CHILDREN),
+            },
+            {
+                ...repeaterProperty('properties', 'properties', PROPERTY_REPEATER_CHILDREN),
+            },
+            {
+                ...repeaterProperty('columns', 'columns', COLUMN_REPEATER_CHILDREN),
+            },
+            {
+                ...repeaterProperty('relatedEntities', 'related-entities', RELATED_ENTITY_REPEATER_CHILDREN),
+                title: fieldTitle('related-entities'),
+            },
+            {
+                ...repeaterProperty('createSections', 'layouts', CREATE_SECTION_REPEATER_CHILDREN),
+                title: fieldTitle('create-sections'),
+            },
+            {
+                ...repeaterProperty('createProperties', 'layouts', CREATE_PROPERTY_LAYOUT_REPEATER_CHILDREN),
+                title: fieldTitle('create-properties'),
+            },
+            {
+                ...repeaterProperty('listActions', 'actions', ACTION_REPEATER_CHILDREN),
+                title: fieldTitle('list-actions'),
+            },
+            {
+                ...repeaterProperty('singleActions', 'actions', ACTION_REPEATER_CHILDREN),
+                title: fieldTitle('single-actions'),
+            },
+            {
+                ...repeaterProperty('pages', 'advanced', PAGE_REPEATER_CHILDREN),
+                title: fieldTitle('pages'),
+            },
+            {
+                name: 'rules',
+                title: fieldTitle('rules'),
+                groupId: 'advanced',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsList.Advanced.CodeEditor,
+                        options: { language: 'json', height: 'h-40' },
+                    },
+                },
+            },
+            {
+                name: 'validations',
+                title: fieldTitle('validations'),
+                groupId: 'advanced',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsList.Advanced.CodeEditor,
+                        options: { language: 'json', height: 'h-40' },
+                    },
+                },
+            },
+            {
+                name: 'commandsJson',
+                title: fieldTitle('commands'),
+                groupId: 'advanced',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsList.Advanced.CodeEditor,
+                        options: { language: 'json', height: 'h-40' },
+                    },
+                },
+            },
+            {
+                name: 'queriesJson',
+                title: fieldTitle('queries'),
+                groupId: 'advanced',
+                schema: {
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsList.Advanced.CodeEditor,
+                        options: { language: 'json', height: 'h-40' },
+                    },
+                },
+            },
             {
                 name: 'content',
-                title: `@${i18n}:entity-definitions.entities.entity-definition.fields.content.title`,
+                title: fieldTitle('content'),
                 groupId: 'schema',
                 schema: {
                     dataType: 'object',
@@ -197,7 +1640,7 @@ function buildEntityDefinitionEntity() {
             { name: 'name', title: '@general:terms.common.name', showAs: { type: AXPWidgetsCatalog.text } },
             {
                 name: 'module',
-                title: `@${i18n}:entity-definitions.entities.entity-definition.fields.module-id.title`,
+                title: fieldTitle('module-id'),
                 showAs: { type: AXPWidgetsCatalog.text },
                 options: { dataPath: 'content.module' },
             },
@@ -218,16 +1661,41 @@ function buildEntityDefinitionEntity() {
             master: {
                 list: {
                     views: [createAllQueryView({ sorts: [{ name: 'name', dir: 'asc' }] })],
-                    actions: [entityMasterViewAction()],
+                    actions: [entityMasterCreateAction(), entityMasterViewAction()],
+                },
+                create: {
+                    sections: [
+                        { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'formats', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'category', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: identityLayout,
+                },
+                update: {
+                    sections: [
+                        { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'formats', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'category', layout: { positions: { lg: { colSpan: 12 } } } },
+                    ],
+                    properties: identityLayout,
                 },
                 single: {
                     title: '{{ name }}',
-                    sections: [{ id: 'basic-info' }, { id: 'schema' }],
+                    sections: [
+                        { id: 'basic-info' },
+                        { id: 'formats' },
+                        { id: 'schema' },
+                    ],
                     properties: [
                         { name: 'name', dataPath: 'content.name', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'module', dataPath: 'content.module', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'title', dataPath: 'content.title', layout: { positions: { lg: { colSpan: 6 } } } },
                         { name: 'icon', dataPath: 'content.icon', layout: { positions: { lg: { colSpan: 6 } } } },
+                        {
+                            name: 'parentKey',
+                            dataPath: 'content.parentKey',
+                            layout: { positions: { lg: { colSpan: 6 } } },
+                        },
                         { name: 'content', layout: { positions: { lg: { colSpan: 12 } } } },
                     ],
                     actions: [...entityMasterRecordActions()],
@@ -240,6 +1708,7 @@ function buildEntityDefinitionEntity() {
 async function entityDefinitionEntityFactory() {
     return buildEntityDefinitionEntity();
 }
+//#endregion
 
 /**
  * Generated bundle index. Do not edit.