@acorex/modules 18.2.1 → 18.2.3

package/fesm2022/acorex-modules-form-template-management.mjs

@@ -1,16 +1,25 @@
-import { AXMEntityCrudServiceImpl, AXPEntityQueryType, AXPEntityCommandScope, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXMEntityCrudServiceImpl, AXPEntityCommandScope, AXPEntityQueryType, AXPWorkflowNavigateAction, AXP_MENU_PROVIDER } from '@acorex/platform/common';
 import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { AXPWidgetsModule } from '@acorex/platform/widgets';
+import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXPWidgetsModule, AXP_TEMPLATE_WIDGET_PROVIDER } from '@acorex/platform/widgets';
 import * as i0 from '@angular/core';
-import { Injectable, NgModule, inject, Injector } from '@angular/core';
-import * as i1 from '@angular/router';
+import { Injectable, NgModule, inject, Injector, ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i1$1 from '@angular/router';
 import { RouterModule } from '@angular/router';
-import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import * as i2$1 from '@acorex/platform/layout/builder';
+import { AXPWidgetsCatalog, AXPWidgetComponent, AXP_WIDGETS_LAYOUT_GROUP, AXPLayoutBuilderModule } from '@acorex/platform/layout/builder';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/core/translation';
+import { AXTranslationModule } from '@acorex/core/translation';
+import * as i3 from '@acorex/platform/workflow';
+import { AXPWorkflowService, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { AXPDesignerConnector } from '@acorex/platform/layout/designer';
 
 const AXMFormTemplateManagementModuleConst = {
     moduleName: 'FormTemplateManagement',
     moduleRoute: 'form-template-management',
-    i18n: '#form-template-management',
+    i18n: 'form-template-management',
     categoryEntity: 'Category',
     templateEntity: 'Template',
 };
@@ -35,22 +44,22 @@ async function factory$1(injector) {
         module: AXMFormTemplateManagementModuleConst.moduleName,
         name: AXMFormTemplateManagementModuleConst.categoryEntity,
         source: '',
-        title: `${i18n}.category`,
+        title: `t("category", { scope: "common" })`,
         formats: {
-            individual: `${i18n}.category`,
-            plural: `${i18n}.categories`,
+            individual: `t("category", { scope: "common" })`,
+            plural: `t("categories", { scope: "common" })`,
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'section',
-                title: `${i18n}.category`,
+                title: `t("category", { scope: "common" })`,
             },
         ],
         properties: [
             {
                 name: 'name',
-                title: '#common.name',
+                title: 't("name", { scope: "common" })',
                 groupId: 'section',
                 options: {
                     sort: {
@@ -71,7 +80,7 @@ async function factory$1(injector) {
             },
             {
                 name: 'title',
-                title: '#common.title',
+                title: 't("title", { scope: "common" })',
                 groupId: 'section',
                 schema: {
                     dataType: 'string',
@@ -114,7 +123,7 @@ async function factory$1(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter, sort: e.sort });
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -220,28 +229,28 @@ async function factory$1(injector) {
                 list: {
                     actions: [
                         {
-                            title: `#common.create`,
+                            title: `t("create", { scope: "common" })`,
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: '#common.deleteItems',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: '#common.detail',
+                            title: 't("detail", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: '#common.delete',
+                            title: 't("delete", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'secondary',
                             type: 'delete',
@@ -251,7 +260,7 @@ async function factory$1(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: '#common.allItem',
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -315,24 +324,27 @@ async function factory(injector) {
         module: AXMFormTemplateManagementModuleConst.moduleName,
         name: AXMFormTemplateManagementModuleConst.templateEntity,
         source: '',
-        title: `${i18n}.template`,
+        title: `t("template",{scope:"${i18n}"})`,
         formats: {
-            individual: `${i18n}.template`,
-            plural: `${i18n}.templates`,
+            individual: `t("template",{scope:"${i18n}"})`,
+            plural: `t("templates",{scope:"${i18n}"})`,
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'section',
-                title: `${i18n}.template`,
+                title: `t("information",{scope:"common"})`,
             },
         ],
         properties: [
             {
                 name: 'name',
-                title: '#common.name',
+                title: 't("name", { scope: "common" })',
                 groupId: 'section',
                 options: {
+                    filter: {
+                        inline: { enabled: true },
+                    },
                     sort: {
                         enabled: true,
                     },
@@ -351,8 +363,16 @@ async function factory(injector) {
             },
             {
                 name: 'title',
-                title: '#common.title',
+                title: 't("title", { scope: "common" })',
                 groupId: 'section',
+                options: {
+                    filter: {
+                        inline: { enabled: true },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
@@ -365,8 +385,73 @@ async function factory(injector) {
                     },
                 ],
             },
+            {
+                name: 'categoryId',
+                title: 't("category", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.categoryEntity}`,
+                            expose: [
+                                { source: 'id', target: 'categoryId' },
+                                { source: 'title', target: 'category.title' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'type',
+                title: `t("template-type",{scope:"${i18n}"})`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'value',
+                            textField: 'title',
+                            defaultValue: '10',
+                            dataSource: [
+                                { value: 10, title: 'Form Template' },
+                                { value: 20, title: 'Widgets Template' },
+                            ],
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'template',
+                title: `t("template",{scope:"${i18n}"})`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.templateDesigner,
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'type' },
+            { name: 'categoryId', options: { dataPath: 'category.title' } },
         ],
-        columns: [{ name: 'name' }, { name: 'title' }],
         commands: {
             create: {
                 execute: async (data) => {
@@ -428,6 +513,28 @@ async function factory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                order: 10,
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                order: 20,
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 update: {
@@ -457,6 +564,26 @@ async function factory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                     ],
                 },
                 single: {
@@ -472,6 +599,16 @@ async function factory(injector) {
                                 },
                             },
                         },
+                        {
+                            id: 'template',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     properties: [
                         {
@@ -494,34 +631,67 @@ async function factory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'template',
+                            layout: {
+                                label: {
+                                    visible: false,
+                                },
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
                 list: {
                     actions: [
                         {
-                            title: `#common.create`,
-                            command: 'create-entity',
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-form-template',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: '#common.deleteItems',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: '#common.detail',
+                            title: 't("detail", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: '#common.delete',
+                            title: 't("delete", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'secondary',
                             type: 'delete',
@@ -531,11 +701,43 @@ async function factory(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: '#common.allItem',
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
-                            sorts: [],
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        },
+                        {
+                            name: 'forms',
+                            title: `t("forms", { scope: "${i18n}" })`,
+                            fixed: true,
+                            columns: [],
+                            conditions: [
+                                {
+                                    name: 'type.value',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 10,
+                                },
+                            ],
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        },
+                        {
+                            name: 'widgets',
+                            title: `t("widgets", { scope: "${i18n}" })`,
+                            fixed: true,
+                            columns: [],
+                            conditions: [
+                                {
+                                    name: 'type.value',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 20,
+                                },
+                            ],
+                            sorts: [{ name: 'title', dir: 'asc' }],
                         },
                     ],
                 },
@@ -601,41 +803,215 @@ class AXMFormTemplateManagementModuleMenuProvider {
     constructor() {
         this.entityService = inject(AXPEntityService);
     }
-    async items() {
+    async provide(context) {
         const scope = AXMFormTemplateManagementModuleConst.i18n;
         const moduleName = AXMFormTemplateManagementModuleConst.moduleName;
-        return [
+        context.addItems([
             {
-                items: [
+                priority: 9001,
+                text: `t('module-name', {scope: ${scope}})`,
+                icon: 'fa-solid fa-file-invoice',
+                children: [
                     {
-                        priority: 9001,
-                        text: `${scope}.module-name`,
-                        icon: 'fa-solid fa-file-invoice',
-                        children: [
-                            {
-                                text: `#common.categories`,
-                                path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.categoryEntity),
-                                priority: 1,
-                            },
-                            {
-                                text: `${scope}.templates`,
-                                path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.templateEntity),
-                                priority: 2,
-                            },
-                            {
-                                text: `${scope}.widgets`,
-                                priority: 3,
-                            },
-                            {
-                                text: `${scope}.designer`,
-                                path: '/forms/designer',
-                                priority: 100,
-                            },
-                        ],
+                        text: `t("categories", { scope: "common" })`,
+                        path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.categoryEntity),
+                        priority: 1,
+                    },
+                    {
+                        text: `t('templates', {scope: ${scope}})`,
+                        path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.templateEntity),
+                        priority: 2,
                     },
                 ],
             },
-        ];
+        ]);
+    }
+}
+
+class AXPTemplateDesignerWidgetViewComponent extends AXPWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.workflow = inject(AXPWorkflowService);
+    }
+    async handleClick() {
+        await this.workflow.execute('design-form-template', { data: { id: this.extractValue('id') } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTemplateDesignerWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", type: AXPTemplateDesignerWidgetViewComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <span
+      class="ax-underline ax-decoration-dotted  ax-underline-offset-8 hover:ax-text-primary-500 ax-cursor-pointer"
+      (click)="handleClick()"
+    >
+      {{ 'edit-template' | translate : { scope: 'form-template-management' } | async }}
+    </span>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i2.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTemplateDesignerWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <span
+      class="ax-underline ax-decoration-dotted  ax-underline-offset-8 hover:ax-text-primary-500 ax-cursor-pointer"
+      (click)="handleClick()"
+    >
+      {{ 'edit-template' | translate : { scope: 'form-template-management' } | async }}
+    </span>
+  `,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, AXButtonModule, AXTranslationModule],
+                }]
+        }] });
+
+var templateDesignerWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPTemplateDesignerWidgetViewComponent: AXPTemplateDesignerWidgetViewComponent
+});
+
+const AXPTemplateDesignerWidget = {
+    name: "template-designer",
+    title: "Template Designer",
+    icon: "fa-solid fa-square",
+    type: 'editor',
+    group: AXP_WIDGETS_LAYOUT_GROUP,
+    visible: false,
+    properties: [
+        AXP_NAME_PROPERTY,
+        AXP_DATA_PATH_PROPERTY,
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return templateDesignerWidgetView_component; }).then((c) => c.AXPTemplateDesignerWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return templateDesignerWidgetView_component; }).then((c) => c.AXPTemplateDesignerWidgetViewComponent),
+        }
+    }
+};
+
+const AXMCreateFormTemplateWorkflow = {
+    startStepId: 'create-form-template',
+    steps: {
+        "create-form-template": {
+            action: 'start-workflow',
+            input: {
+                workflow: "create-entity",
+                context: {
+                    redirect: true,
+                    entity: `${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.templateEntity}`,
+                }
+            },
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'get-template-confirmaton',
+                },
+            ],
+        },
+        "get-template-confirmaton": {
+            action: 'show-prompt-dialog',
+            input: {
+                title: 'Confirm Action',
+                message: `Would you like to proceed with starting template design?`,
+                type: 'info',
+            },
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'template-design',
+                },
+            ],
+        },
+        "template-design": {
+            action: 'open-form-template-designer',
+        },
+    },
+};
+
+class AXPDesignerConnectorImpl extends AXPDesignerConnector {
+    constructor() {
+        super(...arguments);
+        this.service = inject(AXMFormTemplateManagementTemplateEntityService);
+        //#endregion
+    }
+    //#region Save and load Widgets
+    async save(id, content) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            await this.service.updateOne(id, { template: content.json });
+        }
+        else {
+            throw Error("Invalid Id");
+        }
+    }
+    async saveAs(content) {
+        throw Error("Not Implemented");
+    }
+    async load(id) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            return item.template;
+        }
+        else {
+            throw Error("Invalid Id");
+        }
+    }
+}
+
+class AXMOpenFormTemplateDesignerAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.navigation = inject(AXPWorkflowNavigateAction);
+    }
+    async execute(context) {
+        const { id } = context.getVariable('data');
+        context.setVariable('payload', {
+            commands: `/forms/designer?id=${id}`,
+            target: 'blank'
+        });
+        await this.navigation.execute(context);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMDesignFormTemplateWorkflow = {
+    startStepId: 'open-design-designer',
+    steps: {
+        "open-design-designer": {
+            action: 'open-form-template-designer',
+        },
+    },
+};
+
+class AXPTemplateWidgetProviderImpl {
+    constructor() {
+        this.service = inject(AXMFormTemplateManagementTemplateEntityService);
+    }
+    async items(query) {
+        const result = ((await this.service.query(query)).items).map(c => ({
+            id: c.id,
+            title: c.title,
+            group: {
+                name: 'other',
+                order: 2,
+                title: "Saved"
+            },
+            description: c.description
+        }));
+        return result;
+    }
+    async get(id) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            const document = JSON.parse(item.template);
+            return document?.children?.[0];
+        }
+        else {
+            throw Error("Invalid Id");
+        }
     }
 }
 
@@ -645,7 +1021,7 @@ const routes = [
         children: [
             {
                 path: 'designer',
-                loadComponent: () => import('./acorex-modules-form-template-management-designer.page-DC18KFvK.mjs').then((c) => c.AXMFormTemplateManagementModuleDesignerPage),
+                loadComponent: () => import('./acorex-modules-form-template-management-designer.page-NhIPhsRs.mjs').then((c) => c.AXMFormTemplateManagementModuleDesignerPage),
             },
             {
                 path: 'preview',
@@ -660,9 +1036,9 @@ const routes = [
 ];
 class AXMFormTemplateManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, imports: [i1.RouterModule, AXPWidgetsModule,
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, imports: [i1$1.RouterModule, AXPWidgetsModule,
             AXMFormTemplateManagementCategoryEntityModule,
-            AXMFormTemplateManagementTemplateEntityModule] }); }
+            AXMFormTemplateManagementTemplateEntityModule, i2$1.AXPLayoutBuilderModule, i3.AXPWorkflowModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, providers: [
             {
                 provide: AXP_ENTITY_DEFINITION_LOADER,
@@ -674,10 +1050,33 @@ class AXMFormTemplateManagementModule {
                 useClass: AXMFormTemplateManagementModuleMenuProvider,
                 multi: true,
             },
+            {
+                provide: AXPDesignerConnector,
+                useClass: AXPDesignerConnectorImpl
+            },
+            {
+                provide: AXP_TEMPLATE_WIDGET_PROVIDER,
+                useClass: AXPTemplateWidgetProviderImpl,
+                multi: true,
+            }
         ], imports: [RouterModule.forChild(routes),
             AXPWidgetsModule,
             AXMFormTemplateManagementCategoryEntityModule,
-            AXMFormTemplateManagementTemplateEntityModule] }); }
+            AXMFormTemplateManagementTemplateEntityModule,
+            AXPLayoutBuilderModule.forChild({
+                widgets: [
+                    AXPTemplateDesignerWidget
+                ]
+            }),
+            AXPWorkflowModule.forChild({
+                actions: {
+                    'open-form-template-designer': AXMOpenFormTemplateDesignerAction
+                },
+                workflows: {
+                    'create-form-template': AXMCreateFormTemplateWorkflow,
+                    'design-form-template': AXMDesignFormTemplateWorkflow
+                }
+            })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, decorators: [{
             type: NgModule,
@@ -687,6 +1086,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                         AXPWidgetsModule,
                         AXMFormTemplateManagementCategoryEntityModule,
                         AXMFormTemplateManagementTemplateEntityModule,
+                        AXPLayoutBuilderModule.forChild({
+                            widgets: [
+                                AXPTemplateDesignerWidget
+                            ]
+                        }),
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'open-form-template-designer': AXMOpenFormTemplateDesignerAction
+                            },
+                            workflows: {
+                                'create-form-template': AXMCreateFormTemplateWorkflow,
+                                'design-form-template': AXMDesignFormTemplateWorkflow
+                            }
+                        })
                     ],
                     exports: [],
                     declarations: [],
@@ -701,6 +1114,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                             useClass: AXMFormTemplateManagementModuleMenuProvider,
                             multi: true,
                         },
+                        {
+                            provide: AXPDesignerConnector,
+                            useClass: AXPDesignerConnectorImpl
+                        },
+                        {
+                            provide: AXP_TEMPLATE_WIDGET_PROVIDER,
+                            useClass: AXPTemplateWidgetProviderImpl,
+                            multi: true,
+                        }
                     ],
                 }]
         }] });