fix: 修复规则链设计器i18n使用方式

@@ -129,7 +129,7 @@ export interface FormSchema {
   // Variable name bound to v-model Default value
   valueField?: string;
   // Label name
-  label: string | VNode;
+  label: string;
   // Auxiliary text
   subLabel?: string;
   // Help text on the right side of the text

-import { h } from 'vue';
 import {
   AssignToCustomerFieldsEnum,
   AssignToCustomerFieldsNameEnum,
@@ -12,11 +11,11 @@ export const formSchemas: FormSchema[] = [
   {
     field: AssignToCustomerFieldsEnum.CUSTOMER_NAME_PATTERN,
     component: 'Input',
-    label: h('span', t(AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN)),
+    label: t(AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN),
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     componentProps: {
-      placeholder: `请输入${AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN}`,
+      placeholder: `请输入${t(AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN)}`,
     },
   },
   {
@@ -24,18 +23,23 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => AssignToCustomerFieldsNameEnum.CREATE_CUSTOMER_IF_NOT_EXISTS,
+      default: () => t(AssignToCustomerFieldsNameEnum.CREATE_CUSTOMER_IF_NOT_EXISTS),
     }),
   },
   {
     field: AssignToCustomerFieldsEnum.CUSTOMER_CACHE_EXPIRATION,
     component: 'InputNumber',
-    label: h('span', t(AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION)),
-    required: true,
+    label: t(AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION),
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION)}`,
+      },
+    ],
     helpMessage:
       'Specifies maximum time interval allowed to store found customer records. 0 value means that records will never expire.',
     componentProps: {
-      placeholder: `请输入${AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION}`,
+      placeholder: `请输入${t(AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION)}`,
       min: 0,
     },
   },

-import { h } from 'vue';
 import { ClearAlarmFieldsEnum, ClearAlarmFieldsNameEnum } from '../../../enum/formField/action';
 import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ClearAlarmFieldsEnum.ALARM_DETAILS_BUILD_JS,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(ClearAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS)),
+    label: t(ClearAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS),
     componentProps: {
       javaScriptEditorProps: {
         functionName: 'Details',
@@ -25,10 +24,10 @@ export const formSchemas: FormSchema[] = [
   {
     field: ClearAlarmFieldsEnum.ALARM_TYPE,
     component: 'Input',
-    label: h('span', t(ClearAlarmFieldsNameEnum.ALARM_TYPE)),
+    label: t(ClearAlarmFieldsNameEnum.ALARM_TYPE),
     required: true,
     componentProps: {
-      placeholder: `请输入${ClearAlarmFieldsNameEnum.ALARM_TYPE}`,
+      placeholder: `请输入${t(ClearAlarmFieldsNameEnum.ALARM_TYPE)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { CreateAlarmFieldsEnum, CreateAlarmFieldsNameEnum } from '../../../enum/formField/action';
 import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
@@ -14,7 +13,7 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.USE_MESSAGE_ALARM_DATA,
+      default: () => t(CreateAlarmFieldsNameEnum.USE_MESSAGE_ALARM_DATA),
     }),
   },
   {
@@ -23,13 +22,13 @@ export const formSchemas: FormSchema[] = [
     label: '',
     show: ({ model }) => model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.OVERWRITE_ALARM_DETAILS,
+      default: () => t(CreateAlarmFieldsNameEnum.OVERWRITE_ALARM_DETAILS),
     }),
   },
   {
     field: CreateAlarmFieldsEnum.ALARM_DETAILS_BUILD_JS,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(CreateAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS)),
+    label: t(CreateAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS),
     valueField: 'value',
     changeEvent: 'update:value',
     show: ({ model }) =>
@@ -49,13 +48,13 @@ export const formSchemas: FormSchema[] = [
   {
     field: CreateAlarmFieldsEnum.ALARM_TYPE,
     component: 'Input',
-    label: h('span', t(CreateAlarmFieldsNameEnum.ALARM_TYPE)),
+    label: t(CreateAlarmFieldsNameEnum.ALARM_TYPE),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     componentProps: {
-      placeholder: `请输入${CreateAlarmFieldsNameEnum.ALARM_TYPE}`,
+      placeholder: `请输入${t(CreateAlarmFieldsNameEnum.ALARM_TYPE)}`,
     },
   },
   {
@@ -64,19 +63,19 @@ export const formSchemas: FormSchema[] = [
     label: '',
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.DYNAMIC_SEVERITY,
+      default: () => t(CreateAlarmFieldsNameEnum.DYNAMIC_SEVERITY),
     }),
   },
   {
     field: CreateAlarmFieldsEnum.SEVERITY,
     component: 'Input',
-    label: h('span', t(CreateAlarmFieldsNameEnum.SEVERITY)),
+    label: t(CreateAlarmFieldsNameEnum.SEVERITY),
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body. Alarm severity should be system (CRITICAL, MAJOR etc.)',
     ],
     componentProps: {
-      placeholder: `请输入${CreateAlarmFieldsNameEnum.SEVERITY}`,
+      placeholder: `请输入${t(CreateAlarmFieldsNameEnum.SEVERITY)}`,
     },
   },
   {
@@ -85,18 +84,18 @@ export const formSchemas: FormSchema[] = [
     label: '',
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.PROPAGATE,
+      default: () => t(CreateAlarmFieldsNameEnum.PROPAGATE),
     }),
   },
   {
     field: CreateAlarmFieldsEnum.RELATION_TYPES,
     component: 'Select',
-    label: h('span', t(CreateAlarmFieldsNameEnum.RELATION_TYPES)),
+    label: t(CreateAlarmFieldsNameEnum.RELATION_TYPES),
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     componentProps: {
       open: false,
       mode: 'tags',
-      placeholder: `请输入${CreateAlarmFieldsNameEnum.RELATION_TYPES}`,
+      placeholder: `请输入${t(CreateAlarmFieldsNameEnum.RELATION_TYPES)}`,
     },
   },
   {
@@ -105,7 +104,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.PROPAGATE_TO_TENANT,
+      default: () => t(CreateAlarmFieldsNameEnum.PROPAGATE_TO_TENANT),
     }),
   },
   {
@@ -114,7 +113,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
     renderComponentContent: () => ({
-      default: () => CreateAlarmFieldsNameEnum.PROPAGATE_TO_OWNER,
+      default: () => t(CreateAlarmFieldsNameEnum.PROPAGATE_TO_OWNER),
     }),
   },
 ];

-import { h } from 'vue';
 import {
   DirectionEnum,
   DirectionNameEnum,
@@ -18,21 +17,21 @@ export const formSchemas: FormSchema[] = [
   {
     field: CreateRelationFieldsEnum.DIRECTION,
     component: 'Select',
-    label: h('span', t(CreateRelationFieldsNameEnum.DIRECTION)),
-    required: true,
+    label: t(CreateRelationFieldsNameEnum.DIRECTION),
+    rules: [{ required: true, message: `请选择${t(CreateRelationFieldsNameEnum.DIRECTION)}` }],
     componentProps: {
       options: Object.keys(DirectionEnum).map((value) => ({
         label: DirectionNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${CreateRelationFieldsNameEnum.DIRECTION}`,
+      placeholder: `请选择${t(CreateRelationFieldsNameEnum.DIRECTION)}`,
     },
   },
   {
     field: CreateRelationFieldsEnum.ENTITY_TYPE,
     component: 'Select',
-    label: h('span', t(CreateRelationFieldsNameEnum.ENTITY_TYPE)),
+    label: t(CreateRelationFieldsNameEnum.ENTITY_TYPE),
     colProps: { span: 8 },
     required: true,
     componentProps: {
@@ -41,28 +40,29 @@ export const formSchemas: FormSchema[] = [
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${CreateRelationFieldsNameEnum.ENTITY_TYPE}`,
+      placeholder: `请选择${t(CreateRelationFieldsNameEnum.ENTITY_TYPE)}`,
     },
   },
   {
     field: CreateRelationFieldsEnum.ENTITY_NAME_PATTERN,
     component: 'Input',
-    label: h('span', t(CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN)),
+    label: t(CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN),
     colProps: { span: 8 },
-    required: true,
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
+    rules: [
+      { required: true, message: `请输入${t(CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN)}` },
+    ],
     componentProps: {
-      placeholder: `请输入${CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN}`,
+      placeholder: `请输入${t(CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN)}`,
     },
   },
   {
     field: CreateRelationFieldsEnum.ENTITY_TYPE_PATTERN,
     component: 'Input',
-    label: h('span', t(CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN)),
+    label: t(CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN),
     colProps: { span: 8 },
-    required: true,
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -70,25 +70,28 @@ export const formSchemas: FormSchema[] = [
       const type = model[CreateRelationFieldsEnum.ENTITY_TYPE];
       return [EntityTypeEnum.ASSET, EntityTypeEnum.DEVICE].includes(type);
     },
+    rules: [
+      { required: true, message: `请选择${t(CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN)}` },
+    ],
     componentProps: {
-      placeholder: `请选择${CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN}`,
+      placeholder: `请选择${t(CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN)}`,
     },
   },
   {
     field: CreateRelationFieldsEnum.RELATION_TYPE,
     component: 'Input',
-    label: h('span', t(CreateRelationFieldsNameEnum.RELATION_TYPE)),
+    label: t(CreateRelationFieldsNameEnum.RELATION_TYPE),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
     componentProps: {
-      placeholder: `请输入${CreateRelationFieldsNameEnum.RELATION_TYPE}`,
+      placeholder: `请输入${t(CreateRelationFieldsNameEnum.RELATION_TYPE)}`,
     },
   },
   {
     field: CreateRelationFieldsEnum.CREATE_ENTITY_IF_NOT_EXISTS,
     component: 'Checkbox',
-    label: h('span', t(CreateRelationFieldsNameEnum.CREATE_ENTITY_IF_NOT_EXISTS)),
+    label: t(CreateRelationFieldsNameEnum.CREATE_ENTITY_IF_NOT_EXISTS),
     helpMessage: '',
     show: ({ model }) => {
       const type = model[CreateRelationFieldsEnum.ENTITY_TYPE];
@@ -101,7 +104,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CreateRelationFieldsEnum.REMOVE_CURRENT_RELATIONS,
     component: 'Checkbox',
-    label: h('span', t(CreateRelationFieldsNameEnum.REMOVE_CURRENT_RELATIONS)),
+    label: t(CreateRelationFieldsNameEnum.REMOVE_CURRENT_RELATIONS),
     renderComponentContent: () => ({
       default: () =>
         'Removes current relations from the originator of the incoming message based on direction and type.',
@@ -110,7 +113,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CreateRelationFieldsEnum.CHANGE_ORIGINATOR_TO_RELATED_ENTITY,
     component: 'Checkbox',
-    label: h('span', t(CreateRelationFieldsNameEnum.CHANGE_ORIGINATOR_TO_RELATED_ENTITY)),
+    label: t(CreateRelationFieldsNameEnum.CHANGE_ORIGINATOR_TO_RELATED_ENTITY),
     renderComponentContent: () => ({
       default: () => 'Used to process submitted message as a message from another entity.',
     }),
@@ -118,11 +121,11 @@ export const formSchemas: FormSchema[] = [
   {
     field: CreateRelationFieldsEnum.ENTITY_CACHE_EXPIRATION,
     component: 'InputNumber',
-    label: h('span', t(CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION)),
+    label: t(CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION),
     required: true,
     componentProps: {
       min: 0,
-      placeholder: `请输入${CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION}`,
+      placeholder: `请输入${t(CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION)}`,
     },
   },
 ];

-import { h } from 'vue';
 import {
   DelayDeprecatedFieldsEnum,
   DelayDeprecatedFieldsNameEnum,
@@ -11,7 +10,7 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS,
-    label: h('span', t(DelayDeprecatedFieldsNameEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS)),
+    label: t(DelayDeprecatedFieldsNameEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS),
     component: 'Checkbox',
     renderComponentContent: () => ({
       default: () =>
@@ -21,34 +20,43 @@ export const formSchemas: FormSchema[] = [
   {
     field: DelayDeprecatedFieldsEnum.PERIOD_IN_SECONDS_PATTERN,
     component: 'Input',
-    label: h('span', t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN)),
-    required: true,
+    label: t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN),
     ifShow: ({ model }) => model[DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS],
+    rules: [
+      {
+        required: true,
+        message: `请输入${DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN}`,
+      },
+    ],
     componentProps: {
       min: 0,
-      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN}`,
+      placeholder: `请输入${t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN)}`,
     },
   },
   {
     field: DelayDeprecatedFieldsEnum.PERIOD_IN_SECONDS,
     component: 'InputNumber',
-    label: h('span', t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS)),
-    required: true,
+    label: t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS),
     ifShow: ({ model }) =>
       !model[DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS],
+    rules: [
+      { required: true, message: `请输入${t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS)}` },
+    ],
     componentProps: {
       min: 0,
-      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS}`,
+      placeholder: `请输入${t(DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS)}`,
     },
   },
   {
     field: DelayDeprecatedFieldsEnum.MAX_PENDING_MSGS,
     component: 'InputNumber',
-    label: h('span', t(DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS)),
-    required: true,
+    label: t(DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS),
+    rules: [
+      { required: true, message: `请输入${t(DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS)}` },
+    ],
     componentProps: {
       min: 0,
-      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS}`,
+      placeholder: `请输入${t(DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS)}`,
     },
   },
 ];

-import { h } from 'vue';
 import {
   DirectionEnum,
   DirectionNameEnum,
@@ -18,7 +17,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY,
     component: 'Checkbox',
-    label: h('span', t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY)),
+    label: t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY),
     renderComponentContent: () => ({
       default: () =>
         'Deletes relation from the originator of the incoming message to the specified entity or list of entities based on direction and type.',
@@ -27,70 +26,82 @@ export const formSchemas: FormSchema[] = [
   {
     field: DeleteRelationFieldsEnum.DIRECTION,
     component: 'Select',
-    label: h('span', t(DeleteRelationFieldsNameEnum.DIRECTION)),
-    required: true,
+    label: t(DeleteRelationFieldsNameEnum.DIRECTION),
     show: ({ model }) => model[DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY],
+    rules: [
+      {
+        required: true,
+        message: `请选择${t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY)}`,
+      },
+    ],
     componentProps: {
       options: Object.keys(DirectionEnum).map((value) => ({
         label: DirectionNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY}`,
+      placeholder: `请选择${t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY)}`,
     },
   },
   {
     field: DeleteRelationFieldsEnum.ENTITY_TYPE,
     component: 'Select',
-    label: h('span', t(DeleteRelationFieldsNameEnum.ENTITY_TYPE)),
-    required: true,
+    label: t(DeleteRelationFieldsNameEnum.ENTITY_TYPE),
     colProps: { span: 12 },
+    rules: [{ required: true, message: `请选择${t(DeleteRelationFieldsNameEnum.ENTITY_TYPE)}` }],
     componentProps: {
       options: Object.keys(EntityTypeEnum).map((value) => ({
         label: EntityTypeNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${DeleteRelationFieldsNameEnum.ENTITY_TYPE}`,
+      placeholder: `请选择${t(DeleteRelationFieldsNameEnum.ENTITY_TYPE)}`,
     },
   },
   {
     field: DeleteRelationFieldsEnum.ENTITY_NAME_PATTERN,
     component: 'Input',
-    label: h('span', t(DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN)),
-    required: true,
+    label: t(DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN),
     colProps: { span: 12 },
     show: ({ model }) => model[DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY],
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
+    rules: [
+      { required: true, message: `请输入${t(DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN)}` },
+    ],
     componentProps: {
-      placeholder: `请输入${DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN}`,
+      placeholder: `请输入${t(DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN)}`,
     },
   },
   {
     field: DeleteRelationFieldsEnum.RELATION_TYPE,
     component: 'Input',
-    label: h('span', t(DeleteRelationFieldsNameEnum.RELATION_TYPE)),
-    required: true,
+    label: t(DeleteRelationFieldsNameEnum.RELATION_TYPE),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
+    rules: [{ required: true, message: `请输入${t(DeleteRelationFieldsNameEnum.RELATION_TYPE)}` }],
     componentProps: {
-      placeholder: `请输入${DeleteRelationFieldsNameEnum.RELATION_TYPE}`,
+      placeholder: `请输入${t(DeleteRelationFieldsNameEnum.RELATION_TYPE)}`,
     },
   },
   {
     field: DeleteRelationFieldsEnum.ENTITY_CACHE_EXPIRATION,
     component: 'InputNumber',
-    label: h('span', t(DeleteRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION)),
-    required: true,
+    label: t(DeleteRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION),
     helpMessage: [
       'Specifies maximum time interval allowed to store found entity records. 0 value means that records will never expire.',
     ],
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY)}`,
+      },
+    ],
     componentProps: {
       min: 0,
-      placeholder: `请输入${DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY}`,
+      placeholder: `请输入${t(DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY)}`,
     },
   },
 ];

@@ -3,6 +3,9 @@ import {
   DeviceProfileFieldsNameEnum,
 } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
+import { useI18n } from '/@/hooks/web/useI18n';
+
+const { t } = useI18n();
 
 export const formSchemas: FormSchema[] = [
   {
@@ -10,7 +13,7 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => DeviceProfileFieldsNameEnum.PERSIST_ALARM_RULES_STATE,
+      default: () => t(DeviceProfileFieldsNameEnum.PERSIST_ALARM_RULES_STATE),
     }),
   },
   {
@@ -18,7 +21,7 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => DeviceProfileFieldsNameEnum.FETCH_ALARM_RULES_STATE_ON_START,
+      default: () => t(DeviceProfileFieldsNameEnum.FETCH_ALARM_RULES_STATE_ON_START),
     }),
   },
 ];

-import { h } from 'vue';
 import { EntityTypeEnum, EntityTypeNameEnum } from '../../../enum/form';
 import { GeneratorFieldsEnum, GeneratorFieldsNameEnum } from '../../../enum/formField/action';
 import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
@@ -14,34 +13,34 @@ export const formSchemas: FormSchema[] = [
   {
     field: GeneratorFieldsEnum.MSG_COUNT,
     component: 'InputNumber',
-    label: h('span', t(GeneratorFieldsNameEnum.MSG_COUNT)),
-    required: true,
+    label: t(GeneratorFieldsNameEnum.MSG_COUNT),
+    rules: [{ required: true, message: `请输入${t(GeneratorFieldsNameEnum.MSG_COUNT)}` }],
     componentProps: {
       min: 0,
-      placeholder: `请输入${GeneratorFieldsNameEnum.MSG_COUNT}`,
+      placeholder: `请输入${t(GeneratorFieldsNameEnum.MSG_COUNT)}`,
     },
   },
   {
     field: GeneratorFieldsEnum.PERIOD_IN_SECONDS,
     component: 'InputNumber',
-    label: h('span', t(GeneratorFieldsNameEnum.PERIOD_IN_SECONDS)),
-    required: true,
+    label: t(GeneratorFieldsNameEnum.PERIOD_IN_SECONDS),
+    rules: [{ required: true, message: `请输入${t(GeneratorFieldsNameEnum.PERIOD_IN_SECONDS)}` }],
     componentProps: {
       min: 0,
-      placeholder: `请输入${GeneratorFieldsNameEnum.PERIOD_IN_SECONDS}`,
+      placeholder: `请输入${t(GeneratorFieldsNameEnum.PERIOD_IN_SECONDS)}`,
     },
   },
   {
     field: GeneratorFieldsEnum.ORIGINATOR_TYPE,
     component: 'Select',
-    label: h('span', t(GeneratorFieldsNameEnum.ORIGINATOR_TYPE)),
+    label: t(GeneratorFieldsNameEnum.ORIGINATOR_TYPE),
     colProps: { span: 8 },
     componentProps: {
       options: Object.keys(EntityTypeEnum).map((value) => ({
         label: EntityTypeNameEnum[value],
         value,
       })),
-      placeholder: `请选择${GeneratorFieldsNameEnum.ORIGINATOR_TYPE}`,
+      placeholder: `请选择${t(GeneratorFieldsNameEnum.ORIGINATOR_TYPE)}`,
       getPopupContainer: () => document.body,
     },
   },
@@ -58,7 +57,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GeneratorFieldsEnum.JS_SCRIPT,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(GeneratorFieldsNameEnum.JS_SCRIPT)),
+    label: t(GeneratorFieldsNameEnum.JS_SCRIPT),
     valueField: 'value',
     changeEvent: 'update:value',
     componentProps: {

-import { h } from 'vue';
 import { PerimeterTypeEnum, RangeUtilEnum, RangeUtilNameEnum } from '../../../enum/form';
 import {
   GpsGeofencingEventsFieldsEnum,
@@ -13,29 +12,41 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingEventsFieldsEnum.LATITUDE_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME)),
-    required: true,
+    label: t(GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME),
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME)}`,
+      },
+    ],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.LONGITUDE_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME)),
-    required: true,
+    label: t(GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME),
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME)}`,
+      },
+    ],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE,
     component: 'Select',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE)),
-    required: true,
+    label: t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE),
+    rules: [
+      { required: true, message: `请选择${t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE)}` },
+    ],
     componentProps: {
       options: Object.keys(PerimeterTypeEnum).map((value) => ({ label: value, value })),
-      placeholder: `请选择${GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE}`,
+      placeholder: `请选择${t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE)}`,
     },
   },
   {
@@ -43,143 +54,178 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => GpsGeofencingEventsFieldsNameEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
+      default: () =>
+        t(GpsGeofencingEventsFieldsNameEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA),
     }),
   },
   {
     field: GpsGeofencingEventsFieldsEnum.PERIMETER_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME)),
-    required: true,
+    label: t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME),
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.POLYGON &&
       model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME)}`,
+      },
+    ],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.POLYGONS_DEFINITION,
     component: 'Input',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION),
     helpMessage:
       'Please, use the following format for manual definition of polygon: [[lat1,lon1],[lat2,lon2], ... ,[latN,lonN]].',
-    required: true,
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.POLYGON &&
       !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION)}`,
+      },
+    ],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.CENTER_LATITUDE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE),
     colProps: { span: 12 },
-    required: true,
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
       !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    rules: [
+      { required: true, message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE)}` },
+    ],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.CENTER_LONGITUDE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE),
     colProps: { span: 12 },
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
       !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.RANGE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.RANGE)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.RANGE),
     colProps: { span: 12 },
-    required: true,
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
       !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    rules: [{ required: true, message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.RANGE)}` }],
     componentProps: {
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.RANGE}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.RANGE)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.RANGE_UNIT,
     component: 'Select',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT),
     colProps: { span: 12 },
-    required: true,
     ifShow: ({ model }) =>
       model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
       !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    rules: [
+      { required: true, message: `请选择${t(GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT)}` },
+    ],
     componentProps: {
       options: Object.keys(RangeUtilEnum).map((value) => ({
         label: RangeUtilNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT}`,
+      placeholder: `请选择${t(GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.MIN_INSIDE_DURATION,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION),
     colProps: { span: 12 },
-    required: true,
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION)}`,
+      },
+    ],
     componentProps: {
       min: 1,
       max: 2147483647,
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.MIN_INSIDE_DURATION_TIME_UNIT,
     component: 'Select',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT),
     colProps: { span: 12 },
-    required: true,
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT)}`,
+      },
+    ],
     componentProps: {
       options: Object.keys(RangeUtilEnum).map((value) => ({
         label: RangeUtilNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.MIN_OUTSIDE_DURATION,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION),
     colProps: { span: 12 },
-    required: true,
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION)}`,
+      },
+    ],
     componentProps: {
       min: 1,
       max: 2147483647,
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION)}`,
     },
   },
   {
     field: GpsGeofencingEventsFieldsEnum.MIN_OUTSIDE_DURATION_TIME_UNIT,
     component: 'Select',
-    label: h('span', t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT)),
+    label: t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT),
     colProps: { span: 12 },
-    required: true,
+    rules: [
+      {
+        required: true,
+        message: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT)}`,
+      },
+    ],
     componentProps: {
       options: Object.keys(RangeUtilEnum).map((value) => ({
         label: RangeUtilNameEnum[value],
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT}`,
+      placeholder: `请输入${t(GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { LogFieldsEnum, LogFieldsNameEnum } from '../../../enum/formField/action';
 import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
@@ -11,7 +10,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: LogFieldsEnum.JS_SCRIPT,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(LogFieldsNameEnum.JS_SCRIPT)),
+    label: t(LogFieldsNameEnum.JS_SCRIPT),
     valueField: 'value',
     changeEvent: 'update:value',
     componentProps: {

-import { h } from 'vue';
 import { MessageCountFieldsEnum, MessageCountFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
@@ -9,21 +8,21 @@ export const formSchemas: FormSchema[] = [
   {
     field: MessageCountFieldsEnum.INTERVAL,
     component: 'InputNumber',
-    label: h('span', t(MessageCountFieldsNameEnum.INTERVAL)),
-    required: true,
+    label: t(MessageCountFieldsNameEnum.INTERVAL),
+    rules: [{ required: true, message: `请输入${t(MessageCountFieldsNameEnum.INTERVAL)}` }],
     componentProps: {
       step: 1,
       precision: 0,
-      placeholder: `请输入${MessageCountFieldsNameEnum.INTERVAL}`,
+      placeholder: `请输入${t(MessageCountFieldsNameEnum.INTERVAL)}`,
     },
   },
   {
     field: MessageCountFieldsEnum.TELEMETRY_PREFIX,
     component: 'Input',
-    label: h('span', t(MessageCountFieldsNameEnum.TELEMETRY_PREFIX)),
-    required: true,
+    label: t(MessageCountFieldsNameEnum.TELEMETRY_PREFIX),
+    rules: [{ required: true, message: `请输入${t(MessageCountFieldsNameEnum.TELEMETRY_PREFIX)}` }],
     componentProps: {
-      placeholder: `请输入${MessageCountFieldsNameEnum.TELEMETRY_PREFIX}`,
+      placeholder: `请输入${t(MessageCountFieldsNameEnum.TELEMETRY_PREFIX)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { ScopeEnum, ScopeNameEnum } from '../../../enum/form';
 import { PushToEdgeFieldsEnum, PushToEdgeFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
@@ -10,12 +9,12 @@ export const formSchemas: FormSchema[] = [
   {
     field: PushToEdgeFieldsEnum.SCOPE,
     component: 'Select',
-    label: h('span', t(PushToEdgeFieldsNameEnum.SCOPE)),
-    required: true,
+    label: t(PushToEdgeFieldsNameEnum.SCOPE),
+    rules: [{ required: true, message: `请选择${t(PushToEdgeFieldsNameEnum.SCOPE)}` }],
     componentProps: {
       options: Object.keys(ScopeEnum).map((value) => ({ label: ScopeNameEnum[value], value })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${PushToEdgeFieldsNameEnum.SCOPE}`,
+      placeholder: `请选择${t(PushToEdgeFieldsNameEnum.SCOPE)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { RpcCallReplyFieldsEnum, RpcCallReplyFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
@@ -9,9 +8,9 @@ export const formSchemas: FormSchema[] = [
   {
     field: RpcCallReplyFieldsEnum.REQUEST_ID_META_DATA_ATTRIBUTE,
     component: 'Input',
-    label: h('span', t(RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE)),
+    label: t(RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE),
     componentProps: {
-      placeholder: `请输入${RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE}`,
+      placeholder: `请输入${t(RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE)}`,
     },
   },
 ];

-import { h } from 'vue';
 import {
   RpcCallRequestFieldsEnum,
   RpcCallRequestFieldsNameEnum,
@@ -12,11 +11,11 @@ export const formSchemas: FormSchema[] = [
   {
     field: RpcCallRequestFieldsEnum.TIMEOUT_IN_SECONDS,
     component: 'InputNumber',
-    label: h('span', t(RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS)),
+    label: t(RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS),
     required: true,
     componentProps: {
       min: 0,
-      placeholder: `请输入${RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS}`,
+      placeholder: `请输入${t(RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { ScopeEnum, ScopeNameEnum } from '../../../enum/form';
 import {
   SaveAttributesFieldsEnum,
@@ -13,18 +12,18 @@ export const formSchemas: FormSchema[] = [
   {
     field: SaveAttributesFieldsEnum.SCOPE,
     component: 'Select',
-    label: h('span', t(SaveAttributesFieldsNameEnum.SCOPE)),
+    label: t(SaveAttributesFieldsNameEnum.SCOPE),
     required: true,
     componentProps: {
       options: Object.keys(ScopeEnum).map((value) => ({ label: ScopeNameEnum[value], value })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${SaveAttributesFieldsNameEnum.SCOPE}`,
+      placeholder: `请选择${t(SaveAttributesFieldsNameEnum.SCOPE)}`,
     },
   },
   {
     field: SaveAttributesFieldsEnum.NOTIFY_DEVICE,
     component: 'Checkbox',
-    label: h('span', t(SaveAttributesFieldsNameEnum.NOTIFY_DEVICE)),
+    label: t(SaveAttributesFieldsNameEnum.NOTIFY_DEVICE),
     ifShow: ({ model }) => model[SaveAttributesFieldsEnum.SCOPE] === ScopeEnum.SHARED_SCOPE,
     renderComponentContent: () => ({
       default: () =>

@@ -20,7 +20,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: SaveEventFieldsEnum.CONFIGURATION,
     component: 'JSONEditor',
-    label: h('span', t(SaveEventFieldsNameEnum.CONFIGURATION)),
+    label: t(SaveEventFieldsNameEnum.CONFIGURATION),
     valueField: 'value',
     changeEvent: 'update:value',
   },

-import { h } from 'vue';
 import {
   SaveTimeseriesFieldsEnum,
   SaveTimeseriesFieldsNameEnum,
@@ -12,11 +11,11 @@ export const formSchemas: FormSchema[] = [
   {
     field: SaveTimeseriesFieldsEnum.DEFAULT_TTL,
     component: 'InputNumber',
-    label: h('span', t(SaveTimeseriesFieldsNameEnum.DEFAULT_TTL)),
+    label: t(SaveTimeseriesFieldsNameEnum.DEFAULT_TTL),
     required: true,
     componentProps: {
       min: 0,
-      placeholder: `请输入${SaveTimeseriesFieldsNameEnum.DEFAULT_TTL}`,
+      placeholder: `请输入${t(SaveTimeseriesFieldsNameEnum.DEFAULT_TTL)}`,
     },
   },
   {
@@ -24,13 +23,13 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => SaveTimeseriesFieldsNameEnum.DEFAULT_TTL,
+      default: () => t(SaveTimeseriesFieldsNameEnum.DEFAULT_TTL),
     }),
   },
   {
     field: SaveTimeseriesFieldsEnum.USE_SERVER_TS,
     component: 'Checkbox',
-    label: h('span', t(SaveTimeseriesFieldsNameEnum.USE_SERVER_TS)),
+    label: t(SaveTimeseriesFieldsNameEnum.USE_SERVER_TS),
     renderComponentContent: () => ({
       default: () =>
         'Enable this setting to use the timestamp of the message processing instead of the timestamp from the message. Useful for all sorts of sequential processing if you merge messages from multiple sources (devices, assets, etc).',

-import { h } from 'vue';
 import {
   SaveToCustomTableFieldsEnum,
   SaveToCustomTableFieldsNameEnum,
@@ -15,16 +14,16 @@ export const formSchemas: FormSchema[] = [
   {
     field: SaveToCustomTableFieldsEnum.TABLE_NAME,
     component: 'Input',
-    label: h('span', t(SaveToCustomTableFieldsNameEnum.TABLE_NAME)),
+    label: t(SaveToCustomTableFieldsNameEnum.TABLE_NAME),
     required: true,
     componentProps: {
-      placeholder: `请输入${SaveToCustomTableFieldsEnum.TABLE_NAME}`,
+      placeholder: `请输入${t(SaveToCustomTableFieldsNameEnum.TABLE_NAME)}`,
     },
   },
   {
     field: SaveToCustomTableFieldsEnum.FIELDS_MAPPING,
     component: 'AttributeConfiguration',
-    label: h('span', t(SaveToCustomTableFieldsNameEnum.FIELDS_MAPPING)),
+    label: t(SaveToCustomTableFieldsNameEnum.FIELDS_MAPPING),
     required: true,
     valueField: 'value',
     changeEvent: 'update:value',

-import { h } from 'vue';
 import {
   UnassignFromCustomerFieldsEnum,
   UnassignFromCustomerFieldsNameEnum,
@@ -12,27 +11,27 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: UnassignFromCustomerFieldsEnum.CUSTOMER_NAME_PATTERN,
-    label: h('span', t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN)),
+    label: t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN),
     component: 'Input',
     required: true,
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
     componentProps: {
-      placeholder: `请输入${UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN}`,
+      placeholder: `请输入${t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN)}`,
     },
   },
   {
     field: UnassignFromCustomerFieldsEnum.CUSTOMER_CACHE_EXPIRATION,
     component: 'InputNumber',
-    label: h('span', t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION)),
+    label: t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION),
     required: true,
     helpMessage: [
       'Specifies maximum time interval allowed to store found customer records. 0 value means that records will never expire.',
     ],
     componentProps: {
       min: 0,
-      placeholder: `请输入${UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION}`,
+      placeholder: `请输入${t(UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION)}`,
     },
   },
 ];

-import { h } from 'vue';
 import {
   CalculateDeltaFieldsEnum,
   CalculateDeltaFieldsNameEnum,
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CalculateDeltaFieldsEnum.INPUT_VALUE_KEY,
     component: 'Input',
-    label: h('span', t(CalculateDeltaFieldsNameEnum.INPUT_VALUE_KEY)),
+    label: t(CalculateDeltaFieldsNameEnum.INPUT_VALUE_KEY),
     colProps: { span: 8 },
     rules: [
       { required: true, message: `请输入${t(CalculateDeltaFieldsNameEnum.INPUT_VALUE_KEY)}` },
@@ -24,7 +23,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CalculateDeltaFieldsEnum.OUTPUT_VALUE_KEY,
     component: 'Input',
-    label: h('span', t(CalculateDeltaFieldsNameEnum.OUTPUT_VALUE_KEY)),
+    label: t(CalculateDeltaFieldsNameEnum.OUTPUT_VALUE_KEY),
     colProps: { span: 8 },
     rules: [
       { required: true, message: `请输入${t(CalculateDeltaFieldsNameEnum.OUTPUT_VALUE_KEY)}` },
@@ -36,7 +35,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CalculateDeltaFieldsEnum.ROUND,
     component: 'InputNumber',
-    label: h('span', t(CalculateDeltaFieldsNameEnum.ROUND)),
+    label: t(CalculateDeltaFieldsNameEnum.ROUND),
     colProps: { span: 8 },
     componentProps: {
       step: 1,
@@ -77,7 +76,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CalculateDeltaFieldsEnum.PERIOD_VALUE_KEY,
     component: 'Input',
-    label: h('span', t(CalculateDeltaFieldsNameEnum.PERIOD_VALUE_KEY)),
+    label: t(CalculateDeltaFieldsNameEnum.PERIOD_VALUE_KEY),
     required: true,
     ifShow: ({ model }) => model[CalculateDeltaFieldsEnum.ADD_PERIOD_BETWEEN_MSGS],
     componentProps: {

-import { h } from 'vue';
 import {
   CustomerAttributesFieldsEnum,
   CustomerAttributesFieldsNameEnum,
@@ -25,7 +24,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CustomerAttributesFieldsEnum.ATTR_MAPING,
     component: 'AttributeConfiguration',
-    label: h('span', t(CustomerAttributesFieldsNameEnum.ATTR_MAPING)),
+    label: t(CustomerAttributesFieldsNameEnum.ATTR_MAPING),
     slot: CustomerAttributesFieldsEnum.ATTR_MAPING,
     valueField: 'value',
     changeEvent: 'update:value',

-import { h } from 'vue';
 import { DetailsListEnum, DetailsListNameEnum } from '../../../enum/form';
 import {
   CustomerDetailsFieldsEnum,
@@ -13,7 +12,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CustomerDetailsFieldsEnum.DETAILS_LIST,
     component: 'Select',
-    label: h('span', t(CustomerDetailsFieldsNameEnum.DETAILS_LIST)),
+    label: t(CustomerDetailsFieldsNameEnum.DETAILS_LIST),
     rules: [{ required: true, message: `请选择${t(CustomerDetailsFieldsNameEnum.DETAILS_LIST)}` }],
     componentProps: {
       mode: 'multiple',

-import { h } from 'vue';
 import {
   OriginatorAttributesEnum,
   OriginatorAttributesNameEnum,
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.TELL_FAILURE_IF_ABSENT,
     component: 'Checkbox',
-    label: h('span', t(OriginatorAttributesNameEnum.TELL_FAILURE_IF_ABSENT)),
+    label: t(OriginatorAttributesNameEnum.TELL_FAILURE_IF_ABSENT),
     renderComponentContent: () => ({
       default: () =>
         'If at least one selected key doesn\'t exist the outbound message will report "Failure".',
@@ -21,7 +20,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.CLIENT_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(OriginatorAttributesNameEnum.CLIENT_ATTRIBUTE_NAMES)),
+    label: t(OriginatorAttributesNameEnum.CLIENT_ATTRIBUTE_NAMES),
     helpMessage: [
       `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
     ],
@@ -34,7 +33,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.SHARED_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(OriginatorAttributesNameEnum.SHARED_ATTRIBUTE_NAMES)),
+    label: t(OriginatorAttributesNameEnum.SHARED_ATTRIBUTE_NAMES),
     helpMessage: [
       `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
     ],
@@ -47,7 +46,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.SERVER_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(OriginatorAttributesNameEnum.SERVER_ATTRIBUTE_NAMES)),
+    label: t(OriginatorAttributesNameEnum.SERVER_ATTRIBUTE_NAMES),
     helpMessage: [
       `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
     ],
@@ -60,7 +59,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.LATEST_TS_KEY_NAMES,
     component: 'Select',
-    label: h('span', t(OriginatorAttributesNameEnum.LATEST_TS_KEY_NAMES)),
+    label: t(OriginatorAttributesNameEnum.LATEST_TS_KEY_NAMES),
     helpMessage: [
       `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
     ],
@@ -73,7 +72,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorAttributesEnum.GET_LATEST_VALUE_WITH_TS,
     component: 'Checkbox',
-    label: h('span', t(OriginatorAttributesNameEnum.GET_LATEST_VALUE_WITH_TS)),
+    label: t(OriginatorAttributesNameEnum.GET_LATEST_VALUE_WITH_TS),
     renderComponentContent: () => ({
       default: () =>
         'If selected, latest telemetry values will be added to the outbound message metadata with timestamp, e.g: "temp": "{"ts":1574329385897, "value":42}"',

-import { h } from 'vue';
 import { OriginatorFieldsEnum, OriginatorFieldsNameEnum } from '../../../enum/formField/enrichment';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorFieldsEnum.FIELDS_MAPPING,
     component: 'AttributeConfiguration',
-    label: h('span', t(OriginatorFieldsNameEnum.FIELDS_MAPPING)),
+    label: t(OriginatorFieldsNameEnum.FIELDS_MAPPING),
     slot: OriginatorFieldsEnum.FIELDS_MAPPING,
     valueField: 'value',
     changeEvent: 'update:value',

-import { h } from 'vue';
 import {
   AggregationEnum,
   AggregationNameEnum,
@@ -20,7 +19,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.LATEST_TS_KEY_NAMES,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.LATEST_TS_KEY_NAMES)),
+    label: t(OriginatorTelemetryFieldsNameEnum.LATEST_TS_KEY_NAMES),
     componentProps: {
       mode: 'tags',
       open: false,
@@ -31,7 +30,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.FETCH_MODE,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.FETCH_MODE)),
+    label: t(OriginatorTelemetryFieldsNameEnum.FETCH_MODE),
     rules: [
       { required: true, message: `请选择${t(OriginatorTelemetryFieldsNameEnum.FETCH_MODE)}` },
     ],
@@ -44,7 +43,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.AGGREGATION,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.AGGREGATION)),
+    label: t(OriginatorTelemetryFieldsNameEnum.AGGREGATION),
     show: ({ model }) => model[OriginatorTelemetryFieldsEnum.FETCH_MODE] === FetchModeEnum.ALL,
     rules: [
       { required: true, message: `请选择${t(OriginatorTelemetryFieldsNameEnum.AGGREGATION)}` },
@@ -61,20 +60,20 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.ORDER_BY,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.ORDER_BY)),
+    label: t(OriginatorTelemetryFieldsNameEnum.ORDER_BY),
     helpMessage: ['Select to choose telemetry sampling order.'],
     show: ({ model }) => model[OriginatorTelemetryFieldsEnum.FETCH_MODE] === FetchModeEnum.ALL,
     rules: [{ required: true, message: `请选择${OriginatorTelemetryFieldsNameEnum.FETCH_MODE}` }],
     componentProps: {
       options: Object.keys(OrderByEnum).map((value) => ({ label: value, value })),
-      placeholder: `请选择${t(OriginatorTelemetryFieldsNameEnum.FETCH_MODE)}`,
+      placeholder: `请选择${t(OriginatorTelemetryFieldsNameEnum.ORDER_BY)}`,
       getPopupContainer: () => document.body,
     },
   },
   {
     field: OriginatorTelemetryFieldsEnum.LIMIT,
     component: 'InputNumber',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.LIMIT)),
+    label: t(OriginatorTelemetryFieldsNameEnum.LIMIT),
     helpMessage: [
       "Min limit value is 2, max - 1000. In case you want to fetch a single entry, select fetch mode 'FIRST' or 'LAST'.",
     ],
@@ -98,11 +97,11 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.START_INTERVAL,
     component: 'InputNumber',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL)),
+    label: t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL),
     colProps: { span: 12 },
     show: ({ model }) => !model[OriginatorTelemetryFieldsEnum.USE_METADATA_INTERVAL_PATTERNS],
     rules: [
-      { required: true, message: `请输入${OriginatorTelemetryFieldsNameEnum.START_INTERVAL}` },
+      { required: true, message: `请输入${t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL)}` },
     ],
     componentProps: {
       step: 1,
@@ -113,13 +112,13 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.START_INTERVAL_TIME_UNIT,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL_TIME_UNIT)),
+    label: t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL_TIME_UNIT),
     colProps: { span: 12 },
     show: ({ model }) => !model[OriginatorTelemetryFieldsEnum.USE_METADATA_INTERVAL_PATTERNS],
     rules: [
       {
         required: true,
-        message: `请选择${OriginatorTelemetryFieldsNameEnum.START_INTERVAL_TIME_UNIT}`,
+        message: `请选择${t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL_TIME_UNIT)}`,
       },
     ],
     componentProps: {
@@ -134,7 +133,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.END_INTERVAL,
     component: 'InputNumber',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL)),
+    label: t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL),
     colProps: { span: 12 },
     show: ({ model }) => !model[OriginatorTelemetryFieldsEnum.USE_METADATA_INTERVAL_PATTERNS],
     rules: [
@@ -149,7 +148,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.END_INTERVAL_TIME_UNIT,
     component: 'Select',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL_TIME_UNIT)),
+    label: t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL_TIME_UNIT),
     colProps: { span: 12 },
     show: ({ model }) => !model[OriginatorTelemetryFieldsEnum.USE_METADATA_INTERVAL_PATTERNS],
     rules: [
@@ -170,7 +169,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.START_INTERVAL_PATTERN,
     component: 'Input',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL_PATTERN)),
+    label: t(OriginatorTelemetryFieldsNameEnum.START_INTERVAL_PATTERN),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -188,7 +187,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTelemetryFieldsEnum.END_INTERVAL_PATTERN,
     component: 'Input',
-    label: h('span', t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL_PATTERN)),
+    label: t(OriginatorTelemetryFieldsNameEnum.END_INTERVAL_PATTERN),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],

@@ -5,7 +5,7 @@ import {
   RelatedAttributesFieldsEnum,
   RelatedAttributesFieldsNameEnum,
 } from '../../../enum/formField/enrichment';
-import { h } from 'vue';
+
 import { useI18n } from '/@/hooks/web/useI18n';
 const { t } = useI18n();
 
@@ -16,7 +16,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedAttributesFieldsEnum.RELATIONS_QUERY,
     component: 'RelationsQuery',
-    label: h('span', t(RelatedAttributesFieldsNameEnum.RELATIONS_QUERY)),
+    label: t(RelatedAttributesFieldsNameEnum.RELATIONS_QUERY),
     changeEvent: 'update:value',
     valueField: 'value',
     slot: RelatedAttributesFieldsEnum.RELATIONS_QUERY,

-import { h } from 'vue';
 import {
   DirectionEnum,
   DirectionNameEnum,
@@ -46,7 +45,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.DIRECTION,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.DIRECTION)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.DIRECTION),
     colProps: { span: 12 },
     rules: [
       {
@@ -66,7 +65,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.MAX_LEVEL,
     component: 'InputNumber',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.MAX_LEVEL)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.MAX_LEVEL),
     colProps: { span: 12 },
     componentProps: {
       min: 1,
@@ -76,7 +75,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.RELATION_TYPE,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.RELATION_TYPE)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.RELATION_TYPE),
     componentProps: {
       options: Object.keys(RelationTypeEnum).map((value) => ({
         label: RelationTypeNameEnum[value],
@@ -89,7 +88,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.DEVICE_TYPES,
     component: 'ApiSelect',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.DEVICE_TYPES)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.DEVICE_TYPES),
     componentProps: {
       mode: 'multiple',
       api: getDeviceTypes,
@@ -110,7 +109,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.CLIENT_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.CLIENT_ATTRIBUTE_NAMES)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.CLIENT_ATTRIBUTE_NAMES),
     componentProps: {
       open: false,
       mode: 'tags',
@@ -120,7 +119,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.SHARED_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.SHARED_ATTRIBUTE_NAMES)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.SHARED_ATTRIBUTE_NAMES),
     componentProps: {
       open: false,
       mode: 'tags',
@@ -130,7 +129,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.SERVER_ATTRIBUTE_NAMES,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.SERVER_ATTRIBUTE_NAMES)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.SERVER_ATTRIBUTE_NAMES),
     componentProps: {
       open: false,
       mode: 'tags',
@@ -140,7 +139,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: RelatedDeviceAttributeFieldsEnum.LATEST_TS_KEY_NAMES,
     component: 'Select',
-    label: h('span', t(RelatedDeviceAttributeFieldsNameEnum.LATEST_TS_KEY_NAMES)),
+    label: t(RelatedDeviceAttributeFieldsNameEnum.LATEST_TS_KEY_NAMES),
     componentProps: {
       open: false,
       mode: 'tags',

-import { h } from 'vue';
 import {
   TenantAttributesFieldsEnum,
   TenantAttributesFieldsNameEnum,
@@ -25,7 +24,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: TenantAttributesFieldsEnum.ATTR_MAPING,
     component: 'AttributeConfiguration',
-    label: h('span', t(TenantAttributesFieldsNameEnum.ATTR_MAPING)),
+    label: t(TenantAttributesFieldsNameEnum.ATTR_MAPING),
     slot: TenantAttributesFieldsEnum.ATTR_MAPING,
     valueField: 'value',
     changeEvent: 'update:value',

-import { h } from 'vue';
 import { DetailsListEnum, DetailsListNameEnum } from '../../../enum/form';
 import {
   TenantDetailsFieldsEnum,
@@ -13,7 +12,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: TenantDetailsFieldsEnum.DETAILS_LIST,
     component: 'Select',
-    label: h('span', t(TenantDetailsFieldsNameEnum.DETAILS_LIST)),
+    label: t(TenantDetailsFieldsNameEnum.DETAILS_LIST),
     rules: [{ required: true, message: `请选择${t(TenantDetailsFieldsNameEnum.DETAILS_LIST)}` }],
     componentProps: {
       mode: 'multiple',

-import { h } from 'vue';
 import { AlarmNoticeFieldsEnum, AlarmNoticeFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
@@ -9,7 +8,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: AlarmNoticeFieldsEnum.CONFIGURATION,
     component: 'JSONEditor',
-    label: h('span', t(AlarmNoticeFieldsNameEnum.CONFIGURATION)),
+    label: t(AlarmNoticeFieldsNameEnum.CONFIGURATION),
     valueField: 'value',
     changeEvent: 'update:value',
   },

-import { h } from 'vue';
 import { AwsSnsFieldsEnum, AwsSnsFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
@@ -8,38 +7,38 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: AwsSnsFieldsEnum.TOPIC_ARN_PATTERN,
-    label: h('span', t(AwsSnsFieldsNameEnum.TOPIC_ARN_PATTERN)),
+    label: t(AwsSnsFieldsNameEnum.TOPIC_ARN_PATTERN),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSnsFieldsNameEnum.TOPIC_ARN_PATTERN}`,
+      placeholder: `请输入${t(AwsSnsFieldsNameEnum.TOPIC_ARN_PATTERN)}`,
     },
   },
   {
     field: AwsSnsFieldsEnum.ACCESS_KEY_ID,
-    label: h('span', t(AwsSnsFieldsNameEnum.ACCESS_KEY_ID)),
+    label: t(AwsSnsFieldsNameEnum.ACCESS_KEY_ID),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSnsFieldsNameEnum.ACCESS_KEY_ID}`,
+      placeholder: `请输入${t(AwsSnsFieldsNameEnum.ACCESS_KEY_ID)}`,
     },
   },
   {
     field: AwsSnsFieldsEnum.SECRET_ACCESS_KEY,
-    label: h('span', t(AwsSnsFieldsNameEnum.SECRET_ACCESS_KEY)),
+    label: t(AwsSnsFieldsNameEnum.SECRET_ACCESS_KEY),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSnsFieldsNameEnum.SECRET_ACCESS_KEY}`,
+      placeholder: `请输入${t(AwsSnsFieldsNameEnum.SECRET_ACCESS_KEY)}`,
     },
   },
   {
     field: AwsSnsFieldsEnum.REGION,
-    label: h('span', t(AwsSnsFieldsNameEnum.REGION)),
+    label: t(AwsSnsFieldsNameEnum.REGION),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSnsFieldsNameEnum.REGION}`,
+      placeholder: `请输入${t(AwsSnsFieldsNameEnum.REGION)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { QueueTypeEnum, QueueTypeNameEnum } from '../../../enum/form';
 import { AwsSqsFieldsEnum, AwsSqsFieldsNameEnum } from '../../../enum/formField/external';
 import { AttributeConfiguration } from '../../../src/components/AttributeConfiguration';
@@ -12,7 +11,7 @@ useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 export const formSchemas: FormSchema[] = [
   {
     field: AwsSqsFieldsEnum.QUEUE_TYPE,
-    label: h('span', t(AwsSqsFieldsNameEnum.QUEUE_TYPE)),
+    label: t(AwsSqsFieldsNameEnum.QUEUE_TYPE),
     component: 'Select',
     required: true,
     componentProps: {
@@ -21,21 +20,21 @@ export const formSchemas: FormSchema[] = [
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${AwsSqsFieldsNameEnum.QUEUE_TYPE}`,
+      placeholder: `请选择${t(t(AwsSqsFieldsNameEnum.QUEUE_TYPE))}`,
     },
   },
   {
     field: AwsSqsFieldsEnum.QUEUE_URL_PATTERN,
-    label: h('span', t(AwsSqsFieldsNameEnum.QUEUE_URL_PATTERN)),
+    label: t(AwsSqsFieldsNameEnum.QUEUE_URL_PATTERN),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSqsFieldsNameEnum.QUEUE_URL_PATTERN}`,
+      placeholder: `请输入${t(AwsSqsFieldsNameEnum.QUEUE_URL_PATTERN)}`,
     },
   },
   {
     field: AwsSqsFieldsEnum.DELAY_SECONDS,
-    label: h('span', t(AwsSqsFieldsNameEnum.DELAY_SECONDS)),
+    label: t(AwsSqsFieldsNameEnum.DELAY_SECONDS),
     component: 'Input',
     required: true,
     helpMessage: [
@@ -43,12 +42,12 @@ export const formSchemas: FormSchema[] = [
     ],
     show: ({ model }) => model[AwsSqsFieldsEnum.QUEUE_TYPE] === QueueTypeEnum.STANDARD,
     componentProps: {
-      placeholder: `请输入${AwsSqsFieldsNameEnum.DELAY_SECONDS}`,
+      placeholder: `请输入${t(AwsSqsFieldsNameEnum.DELAY_SECONDS)}`,
     },
   },
   {
     field: AwsSqsFieldsEnum.MESSAGE_ATTRIBUTES,
-    label: h('span', t(AwsSqsFieldsNameEnum.MESSAGE_ATTRIBUTES)),
+    label: t(AwsSqsFieldsNameEnum.MESSAGE_ATTRIBUTES),
     component: 'AttributeConfiguration',
     helpMessage:
       'Use ${metadataKey} for value from metadata, $[messageKey] for value from message body in name/value fields',
@@ -56,29 +55,29 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: AwsSqsFieldsEnum.ACCESS_KEY_ID,
-    label: h('span', t(AwsSqsFieldsNameEnum.ACCESS_KEY_ID)),
+    label: t(AwsSqsFieldsNameEnum.ACCESS_KEY_ID),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSqsFieldsNameEnum.ACCESS_KEY_ID}`,
+      placeholder: `请输入${t(AwsSqsFieldsNameEnum.ACCESS_KEY_ID)}`,
     },
   },
   {
     field: AwsSqsFieldsEnum.SECRET_ACCESS_KEY,
-    label: h('span', t(AwsSqsFieldsNameEnum.SECRET_ACCESS_KEY)),
+    label: t(AwsSqsFieldsNameEnum.SECRET_ACCESS_KEY),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSqsFieldsNameEnum.SECRET_ACCESS_KEY}`,
+      placeholder: `请输入${t(AwsSqsFieldsNameEnum.SECRET_ACCESS_KEY)}`,
     },
   },
   {
     field: AwsSqsFieldsEnum.REGION,
-    label: h('span', t(AwsSqsFieldsNameEnum.REGION)),
+    label: t(AwsSqsFieldsNameEnum.REGION),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AwsSqsFieldsNameEnum.REGION}`,
+      placeholder: `请输入${t(AwsSqsFieldsNameEnum.REGION)}`,
     },
   },
 ];

@@ -3,6 +3,9 @@ import {
   AzureIotHubFieldsNameEnum,
 } from '../../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
+import { useI18n } from '/@/hooks/web/useI18n';
+
+const { t } = useI18n();
 
 export enum CredentialsTypeEnum {
   PEM = 'cert.PEM',
@@ -53,7 +56,7 @@ export const formSchemas = (
   return [
     {
       field: AzureIotHubFieldsEnum.TYPE,
-      label: AzureIotHubFieldsNameEnum.TYPE,
+      label: t(AzureIotHubFieldsNameEnum.TYPE),
       component: 'Select',
       required: true,
       defaultValue: CredentialsTypeEnum.SHARED_ACCESS_SIGNATURE,
@@ -61,8 +64,9 @@ export const formSchemas = (
         const { setFieldsValue } = formActionType;
         return {
           options: credentialsTypeOptions,
-          placeholder: `请选择${AzureIotHubFieldsNameEnum.TYPE}`,
+          placeholder: `请选择${t(AzureIotHubFieldsNameEnum.TYPE)}`,
           getPopupContainer: () => document.body,
+          allowClear: false,
           onChange(
             value: CredentialsTypeEnum,
             option: { label: CredentialsTypeNameEnum; value: CredentialsTypeEnum }
@@ -84,24 +88,24 @@ export const formSchemas = (
     },
     {
       field: AzureIotHubFieldsEnum.SAS_KEY,
-      label: AzureIotHubFieldsNameEnum.SAS_KEY,
+      label: t(AzureIotHubFieldsNameEnum.SAS_KEY),
       required: true,
       component: 'Input',
       ifShow: ({ model }) =>
         model[AzureIotHubFieldsEnum.TYPE] === CredentialsTypeEnum.SHARED_ACCESS_SIGNATURE,
       componentProps: {
-        placeholder: `请输入${AzureIotHubFieldsNameEnum.SAS_KEY}`,
+        placeholder: `请输入${t(AzureIotHubFieldsNameEnum.SAS_KEY)}`,
       },
     },
     {
       field: AzureIotHubFieldsEnum.CA_CERT_FILE_NAME,
-      label: AzureIotHubFieldsNameEnum.CA_CERT_FILE_NAME,
+      label: t(AzureIotHubFieldsNameEnum.CA_CERT_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: AzureIotHubFieldsEnum.CA_CERT,
-      label: AzureIotHubFieldsNameEnum.CA_CERT,
+      label: t(AzureIotHubFieldsNameEnum.CA_CERT),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -118,13 +122,13 @@ export const formSchemas = (
     },
     {
       field: AzureIotHubFieldsEnum.CERT_FILE_NAME,
-      label: AzureIotHubFieldsNameEnum.CERT_FILE_NAME,
+      label: t(AzureIotHubFieldsNameEnum.CERT_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: AzureIotHubFieldsEnum.CERT,
-      label: AzureIotHubFieldsNameEnum.CERT,
+      label: t(AzureIotHubFieldsNameEnum.CERT),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -143,13 +147,13 @@ export const formSchemas = (
     },
     {
       field: AzureIotHubFieldsEnum.PRIVATE_KEY_FILE_NAME,
-      label: AzureIotHubFieldsNameEnum.PRIVATE_KEY_FILE_NAME,
+      label: t(AzureIotHubFieldsNameEnum.PRIVATE_KEY_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: AzureIotHubFieldsEnum.PRIVATE_KEY,
-      label: AzureIotHubFieldsNameEnum.PRIVATE_KEY,
+      label: t(AzureIotHubFieldsNameEnum.PRIVATE_KEY),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -168,11 +172,11 @@ export const formSchemas = (
     },
     {
       field: AzureIotHubFieldsEnum.PASSWORD,
-      label: AzureIotHubFieldsNameEnum.PASSWORD,
+      label: t(AzureIotHubFieldsNameEnum.PASSWORD),
       component: 'InputPassword',
       ifShow: ({ model }) => model[AzureIotHubFieldsEnum.TYPE] === CredentialsTypeEnum.PEM,
       componentProps: {
-        placeholder: `请输入${AzureIotHubFieldsNameEnum.PASSWORD}`,
+        placeholder: `请输入${t(AzureIotHubFieldsNameEnum.PASSWORD)}`,
       },
     },
   ];

 import { AzureIotHubFieldsEnum, AzureIotHubFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { CredentialsCard } from './CredentialsCard';
-import { h } from 'vue';
+
 import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
@@ -11,31 +11,31 @@ useComponentRegister('CredentialsCard', CredentialsCard);
 export const formSchemas: FormSchema[] = [
   {
     field: AzureIotHubFieldsEnum.TOPIC_PATTERN,
-    label: h('span', t(AzureIotHubFieldsNameEnum.TOPIC_PATTERN)),
+    label: t(AzureIotHubFieldsNameEnum.TOPIC_PATTERN),
     component: 'Input',
     required: true,
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     componentProps: {
-      placeholder: `请输入${AzureIotHubFieldsNameEnum.TOPIC_PATTERN}`,
+      placeholder: `请输入${t(AzureIotHubFieldsNameEnum.TOPIC_PATTERN)}`,
     },
   },
   {
     field: AzureIotHubFieldsEnum.HOST,
-    label: h('span', t(AzureIotHubFieldsNameEnum.HOST)),
+    label: t(AzureIotHubFieldsNameEnum.HOST),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AzureIotHubFieldsNameEnum.HOST}`,
+      placeholder: `请输入${t(AzureIotHubFieldsNameEnum.HOST)}`,
     },
   },
   {
     field: AzureIotHubFieldsEnum.CLIENT_ID,
-    label: h('span', t(AzureIotHubFieldsNameEnum.CLIENT_ID)),
+    label: t(AzureIotHubFieldsNameEnum.CLIENT_ID),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${AzureIotHubFieldsNameEnum.CLIENT_ID}`,
+      placeholder: `请输入${t(AzureIotHubFieldsNameEnum.CLIENT_ID)}`,
     },
   },
   {

@@ -2,7 +2,7 @@ import { GcpPubsubFieldsEnum, GcpPubsubFieldsNameEnum } from '../../../enum/form
 import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
 import { FileItemType, getFileData } from '../AzureIotHub/CredentialsCard/config';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
-import { h } from 'vue';
+
 import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
@@ -12,34 +12,34 @@ useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 export const formSchemas: FormSchema[] = [
   {
     field: GcpPubsubFieldsEnum.PROJECT_ID,
-    label: h('span', t(GcpPubsubFieldsNameEnum.PROJECT_ID)),
+    label: t(GcpPubsubFieldsNameEnum.PROJECT_ID),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${GcpPubsubFieldsNameEnum.PROJECT_ID}`,
+      placeholder: `请输入${t(GcpPubsubFieldsNameEnum.PROJECT_ID)}`,
     },
   },
   {
     field: GcpPubsubFieldsEnum.TOPIC_NAME,
-    label: h('span', t(GcpPubsubFieldsNameEnum.TOPIC_NAME)),
+    label: t(GcpPubsubFieldsNameEnum.TOPIC_NAME),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${GcpPubsubFieldsNameEnum.TOPIC_NAME}`,
+      placeholder: `请输入${t(GcpPubsubFieldsNameEnum.TOPIC_NAME)}`,
     },
   },
   {
     field: GcpPubsubFieldsEnum.SERVICE_ACCOUNT_KEY_FILE_NAME,
-    label: h('span', t(GcpPubsubFieldsNameEnum.SERVICE_ACCOUNT_KEY_FILE_NAME)),
+    label: t(GcpPubsubFieldsNameEnum.SERVICE_ACCOUNT_KEY_FILE_NAME),
     component: 'Input',
     show: false,
     componentProps: {
-      placeholder: `请输入${GcpPubsubFieldsNameEnum.TOPIC_NAME}`,
+      placeholder: `请输入${t(GcpPubsubFieldsNameEnum.TOPIC_NAME)}`,
     },
   },
   {
     field: GcpPubsubFieldsEnum.SERVICE_ACCOUNT_KEY,
-    label: h('span', t(GcpPubsubFieldsNameEnum.SERVICE_ACCOUNT_KEY)),
+    label: t(GcpPubsubFieldsNameEnum.SERVICE_ACCOUNT_KEY),
     component: 'ApiUpload',
     valueField: 'fileList',
     changeEvent: 'update:fileList',
@@ -57,7 +57,7 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: GcpPubsubFieldsEnum.MESSAGE_ATTRIBUTES,
-    label: h('span', t(GcpPubsubFieldsNameEnum.MESSAGE_ATTRIBUTES)),
+    label: t(GcpPubsubFieldsNameEnum.MESSAGE_ATTRIBUTES),
     component: 'AttributeConfiguration',
     helpMessage:
       'Use ${metadataKey} for value from metadata, $[messageKey] for value from message body in name/value fields',

@@ -2,7 +2,7 @@ import { KafkaFieldsEnum, KafkaFieldsNameEnum } from '../../../enum/formField/ex
 import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { CharsetEncodingEnum, CharsetEncodingNameEnum } from '../../../enum/form';
-import { h } from 'vue';
+
 import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
@@ -12,63 +12,63 @@ useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 export const formSchemas: FormSchema[] = [
   {
     field: KafkaFieldsEnum.TOPIC_PATTERN,
-    label: h('span', t(KafkaFieldsNameEnum.TOPIC_PATTERN)),
+    label: t(KafkaFieldsNameEnum.TOPIC_PATTERN),
     component: 'Input',
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     required: true,
     componentProps: {
-      placeholder: `请输入${KafkaFieldsEnum.TOPIC_PATTERN}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.TOPIC_PATTERN)}`,
     },
   },
   {
     field: KafkaFieldsEnum.BOOTSTRAP_SERVERS,
-    label: h('span', t(KafkaFieldsNameEnum.BOOTSTRAP_SERVERS)),
+    label: t(KafkaFieldsNameEnum.BOOTSTRAP_SERVERS),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${KafkaFieldsEnum.BOOTSTRAP_SERVERS}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.BOOTSTRAP_SERVERS)}`,
     },
   },
   {
     field: KafkaFieldsEnum.RETRIES,
-    label: h('span', t(KafkaFieldsNameEnum.RETRIES)),
+    label: t(KafkaFieldsNameEnum.RETRIES),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${KafkaFieldsEnum.BOOTSTRAP_SERVERS}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.BOOTSTRAP_SERVERS)}`,
     },
   },
   {
     field: KafkaFieldsEnum.BATCH_SIZE,
-    label: h('span', t(KafkaFieldsNameEnum.BATCH_SIZE)),
+    label: t(KafkaFieldsNameEnum.BATCH_SIZE),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${KafkaFieldsEnum.BATCH_SIZE}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.BATCH_SIZE)}`,
     },
   },
   {
     field: KafkaFieldsEnum.LINGER,
-    label: h('span', t(KafkaFieldsNameEnum.LINGER)),
+    label: t(KafkaFieldsNameEnum.LINGER),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${KafkaFieldsEnum.LINGER}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.LINGER)}`,
     },
   },
   {
     field: KafkaFieldsEnum.BUFFER_MEMORY,
-    label: h('span', t(KafkaFieldsNameEnum.BUFFER_MEMORY)),
+    label: t(KafkaFieldsNameEnum.BUFFER_MEMORY),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${KafkaFieldsEnum.BUFFER_MEMORY}`,
+      placeholder: `请输入${t(KafkaFieldsEnum.BUFFER_MEMORY)}`,
     },
   },
   {
     field: KafkaFieldsEnum.ACKS,
-    label: h('span', t(KafkaFieldsEnum.ACKS)),
+    label: t(KafkaFieldsEnum.ACKS),
     component: 'Select',
     required: true,
     componentProps: {
@@ -78,37 +78,37 @@ export const formSchemas: FormSchema[] = [
         { label: '0', value: '0' },
         { label: '1', value: '1' },
       ],
-      placeholder: `请选择${KafkaFieldsEnum.BUFFER_MEMORY}`,
+      placeholder: `请选择${t(KafkaFieldsEnum.ACKS)}`,
       getPopupContainer: () => document.body,
     },
   },
   {
     field: KafkaFieldsEnum.KEY_SERIALIZER,
-    label: h('span', t(KafkaFieldsNameEnum.KEY_SERIALIZER)),
+    label: t(KafkaFieldsNameEnum.KEY_SERIALIZER),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${KafkaFieldsEnum.KEY_SERIALIZER}`,
+      placeholder: `请输入${t(KafkaFieldsNameEnum.KEY_SERIALIZER)}`,
     },
   },
   {
     field: KafkaFieldsEnum.VALUE_SERIALIZER,
-    label: h('span', t(KafkaFieldsNameEnum.VALUE_SERIALIZER)),
+    label: t(KafkaFieldsNameEnum.VALUE_SERIALIZER),
     component: 'Input',
     required: true,
     componentProps: {
-      placeholder: `请输入${KafkaFieldsEnum.VALUE_SERIALIZER}`,
+      placeholder: `请输入${t(KafkaFieldsNameEnum.VALUE_SERIALIZER)}`,
     },
   },
   {
     field: KafkaFieldsEnum.OTHER_PROPERTIES,
-    label: h('span', t(KafkaFieldsNameEnum.OTHER_PROPERTIES)),
+    label: t(KafkaFieldsNameEnum.OTHER_PROPERTIES),
     component: 'AttributeConfiguration',
     slot: KafkaFieldsEnum.OTHER_PROPERTIES,
   },
   {
     field: KafkaFieldsEnum.ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS,
-    label: h('span', t(KafkaFieldsNameEnum.ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS)),
+    label: t(KafkaFieldsNameEnum.ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS),
     component: 'Checkbox',
     renderComponentContent: () => ({
       default: () =>
@@ -117,7 +117,7 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: KafkaFieldsEnum.KAFKA_HEADERS_CHARSET,
-    label: h('span', t(KafkaFieldsNameEnum.KAFKA_HEADERS_CHARSET)),
+    label: t(KafkaFieldsNameEnum.KAFKA_HEADERS_CHARSET),
     component: 'Select',
     required: true,
     show: ({ model }) => model[KafkaFieldsEnum.ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS],
@@ -126,7 +126,7 @@ export const formSchemas: FormSchema[] = [
         label: CharsetEncodingNameEnum[value],
         value,
       })),
-      placeholder: `请选择${KafkaFieldsEnum.KAFKA_HEADERS_CHARSET}`,
+      placeholder: `请选择${t(KafkaFieldsEnum.KAFKA_HEADERS_CHARSET)}`,
       getPopupContainer: () => document.body,
     },
   },

 import { MqttFieldsEnum, MqttFieldsNameEnum } from '../../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
+import { useI18n } from '/@/hooks/web/useI18n';
+
+const { t } = useI18n();
 
 // Credentials type
 export enum CredentialsTypeEnum {
@@ -51,15 +54,16 @@ export const formSchemas = (
   return [
     {
       field: MqttFieldsEnum.TYPE,
-      label: MqttFieldsNameEnum.TYPE,
+      label: t(MqttFieldsNameEnum.TYPE),
       component: 'Select',
       required: true,
       defaultValue: CredentialsTypeEnum.ANONYMOUS,
       componentProps: ({ formActionType }) => {
         const { setFieldsValue } = formActionType;
         return {
+          allowClear: false,
           options: credentialsTypeOptions,
-          placeholder: `请选择${MqttFieldsNameEnum.TYPE}`,
+          placeholder: `请选择${t(MqttFieldsNameEnum.TYPE)}`,
           getPopupContainer: () => document.body,
           onChange(
             value: CredentialsTypeEnum,
@@ -81,23 +85,23 @@ export const formSchemas = (
     },
     {
       field: MqttFieldsEnum.USERNAME,
-      label: MqttFieldsNameEnum.USERNAME,
+      label: t(MqttFieldsNameEnum.USERNAME),
       component: 'Input',
       required: true,
       ifShow: ({ model }) => model[MqttFieldsEnum.TYPE] === CredentialsTypeEnum.BASIC,
       componentProps: {
-        placeholder: `请输入${MqttFieldsNameEnum.USERNAME}`,
+        placeholder: `请输入${t(MqttFieldsNameEnum.USERNAME)}`,
       },
     },
     {
       field: MqttFieldsEnum.CA_CERT_FILE_NAME,
-      label: MqttFieldsNameEnum.CA_CERT_FILE_NAME,
+      label: t(MqttFieldsNameEnum.CA_CERT_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: MqttFieldsEnum.CA_CERT,
-      label: MqttFieldsNameEnum.CA_CERT,
+      label: t(MqttFieldsNameEnum.CA_CERT),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -116,13 +120,13 @@ export const formSchemas = (
     },
     {
       field: MqttFieldsEnum.CERT_FILE_NAME,
-      label: MqttFieldsNameEnum.CERT_FILE_NAME,
+      label: t(MqttFieldsNameEnum.CERT_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: MqttFieldsEnum.CERT,
-      label: MqttFieldsNameEnum.CERT,
+      label: t(MqttFieldsNameEnum.CERT),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -141,13 +145,13 @@ export const formSchemas = (
     },
     {
       field: MqttFieldsEnum.PRIVATE_KEY_FILE_NAME,
-      label: MqttFieldsNameEnum.PRIVATE_KEY_FILE_NAME,
+      label: t(MqttFieldsNameEnum.PRIVATE_KEY_FILE_NAME),
       component: 'InputPassword',
       show: false,
     },
     {
       field: MqttFieldsEnum.PRIVATE_KEY,
-      label: MqttFieldsNameEnum.PRIVATE_KEY,
+      label: t(MqttFieldsNameEnum.PRIVATE_KEY),
       component: 'ApiUpload',
       valueField: 'fileList',
       changeEvent: 'update:fileList',
@@ -166,13 +170,13 @@ export const formSchemas = (
     },
     {
       field: MqttFieldsEnum.PASSWORD,
-      label: MqttFieldsNameEnum.PASSWORD,
+      label: t(MqttFieldsNameEnum.PASSWORD),
       component: 'InputPassword',
       ifShow: ({ model }) =>
         model[MqttFieldsEnum.TYPE] === CredentialsTypeEnum.PEM ||
         model[MqttFieldsEnum.TYPE] === CredentialsTypeEnum.BASIC,
       componentProps: {
-        placeholder: `请输入${MqttFieldsNameEnum.PASSWORD}`,
+        placeholder: `请输入${t(MqttFieldsNameEnum.PASSWORD)}`,
       },
     },
   ];

-import { h } from 'vue';
 import { MqttFieldsEnum, MqttFieldsNameEnum } from '../../../enum/formField/external';
 import { CredentialsCard } from './CredentialsCard';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
@@ -11,58 +10,58 @@ useComponentRegister('CredentialsCard', CredentialsCard);
 export const formSchemas: FormSchema[] = [
   {
     field: MqttFieldsEnum.TOPIC_PATTERN,
-    label: h('span', t(MqttFieldsNameEnum.TOPIC_PATTERN)),
+    label: t(MqttFieldsNameEnum.TOPIC_PATTERN),
     component: 'Input',
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     required: true,
     componentProps: {
-      placeholder: `请输入${MqttFieldsNameEnum.TOPIC_PATTERN}`,
+      placeholder: `请输入${t(MqttFieldsNameEnum.TOPIC_PATTERN)}`,
     },
   },
   {
     field: MqttFieldsEnum.HOST,
-    label: h('span', t(MqttFieldsNameEnum.HOST)),
+    label: t(MqttFieldsNameEnum.HOST),
     component: 'Input',
     required: true,
     colProps: { span: 8 },
     componentProps: {
-      placeholder: `请输入${MqttFieldsNameEnum.HOST}`,
+      placeholder: `请输入${t(MqttFieldsNameEnum.HOST)}`,
     },
   },
   {
     field: MqttFieldsEnum.PORT,
-    label: h('span', t(MqttFieldsNameEnum.PORT)),
+    label: t(MqttFieldsNameEnum.PORT),
     component: 'InputNumber',
     required: true,
     colProps: { span: 8 },
     componentProps: {
-      placeholder: `请输入${MqttFieldsNameEnum.PORT}`,
+      placeholder: `请输入${t(MqttFieldsNameEnum.PORT)}`,
     },
   },
   {
     field: MqttFieldsEnum.CONNECT_TIMEOUT_SEC,
-    label: h('span', t(MqttFieldsNameEnum.CONNECT_TIMEOUT_SEC)),
+    label: t(MqttFieldsNameEnum.CONNECT_TIMEOUT_SEC),
     component: 'Input',
     required: true,
     colProps: { span: 8 },
     componentProps: {
-      placeholder: `请输入${MqttFieldsNameEnum.CONNECT_TIMEOUT_SEC}`,
+      placeholder: `请输入${t(MqttFieldsNameEnum.CONNECT_TIMEOUT_SEC)}`,
     },
   },
   {
     field: MqttFieldsEnum.CLIENT_ID,
-    label: h('span', t(MqttFieldsNameEnum.CLIENT_ID)),
+    label: t(MqttFieldsNameEnum.CLIENT_ID),
     component: 'Input',
     helpMessage:
       'Hint: Optional. Leave empty for auto-generated Client ID. Be careful when specifying the Client ID. Majority of the MQTT brokers will not allow multiple connections with the same Client ID. To connect to such brokers, your mqtt Client ID must be unique. When platform is running in a micro-services mode, the copy of rule node is launched in each micro-service. This will automatically lead to multiple mqtt clients with the same ID and may cause failures of the rule node. To avoid such failures enable "Add Service ID as suffix to Client ID" option below.',
     componentProps: {
-      placeholder: `请输入${MqttFieldsNameEnum.TOPIC_PATTERN}`,
+      placeholder: `请输入${t(MqttFieldsNameEnum.TOPIC_PATTERN)}`,
     },
   },
   {
     field: MqttFieldsEnum.APPEND_CLIENT_ID_SUFFIX,
-    label: h('span', t(MqttFieldsNameEnum.APPEND_CLIENT_ID_SUFFIX)),
+    label: t(MqttFieldsNameEnum.APPEND_CLIENT_ID_SUFFIX),
     component: 'Checkbox',
     renderComponentContent: () => ({
       default: () =>
@@ -80,7 +79,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => MqttFieldsNameEnum.CLEAN_SESSION,
+      default: () => t(MqttFieldsNameEnum.CLEAN_SESSION),
     }),
   },
   {
@@ -88,12 +87,12 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => MqttFieldsNameEnum.SSL,
+      default: () => t(MqttFieldsNameEnum.SSL),
     }),
   },
   {
     field: MqttFieldsEnum.CREDENTIALS,
-    label: h('span', t(MqttFieldsNameEnum.CREDENTIALS)),
+    label: t(MqttFieldsNameEnum.CREDENTIALS),
     component: 'CredentialsCard',
     slot: MqttFieldsEnum.CREDENTIALS,
   },

-import { h } from 'vue';
 import { MessagePropertiesEnum } from '../../../enum/form';
 import { RabbitmqFieldsEnum, RabbitmqFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
@@ -9,73 +8,73 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: RabbitmqFieldsEnum.EXCHANGE_NAME_PATTERN,
-    label: h('span', t(RabbitmqFieldsNameEnum.EXCHANGE_NAME_PATTERN)),
+    label: t(RabbitmqFieldsNameEnum.EXCHANGE_NAME_PATTERN),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.EXCHANGE_NAME_PATTERN}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.EXCHANGE_NAME_PATTERN)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.ROUTING_KEY_PATTERN,
-    label: h('span', t(RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN)),
+    label: t(RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.MESSAGE_PROPERTIES,
-    label: h('span', t(RabbitmqFieldsNameEnum.MESSAGE_PROPERTIES)),
+    label: t(RabbitmqFieldsNameEnum.MESSAGE_PROPERTIES),
     component: 'Select',
     componentProps: {
       allowClear: true,
       options: Object.keys(MessagePropertiesEnum).map((value) => ({ label: value, value })),
-      placeholder: `请选择${RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN}`,
+      placeholder: `请选择${t(RabbitmqFieldsNameEnum.ROUTING_KEY_PATTERN)}`,
       getPopupContainer: () => document.body,
     },
   },
   {
     field: RabbitmqFieldsEnum.HOST,
-    label: h('span', t(RabbitmqFieldsNameEnum.HOST)),
+    label: t(RabbitmqFieldsNameEnum.HOST),
     component: 'Input',
     required: true,
     colProps: { span: 12 },
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.HOST}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.HOST)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.PORT,
-    label: h('span', t(RabbitmqFieldsNameEnum.PORT)),
+    label: t(RabbitmqFieldsNameEnum.PORT),
     component: 'InputNumber',
     required: true,
     colProps: { span: 12 },
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.PORT}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.PORT)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.VIRTUAL_HOST,
-    label: h('span', t(RabbitmqFieldsNameEnum.VIRTUAL_HOST)),
+    label: t(RabbitmqFieldsNameEnum.VIRTUAL_HOST),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.VIRTUAL_HOST}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.VIRTUAL_HOST)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.USERNAME,
-    label: h('span', t(RabbitmqFieldsNameEnum.USERNAME)),
+    label: t(RabbitmqFieldsNameEnum.USERNAME),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.USERNAME}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.USERNAME)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.PASSWORD,
-    label: h('span', t(RabbitmqFieldsNameEnum.PASSWORD)),
+    label: t(RabbitmqFieldsNameEnum.PASSWORD),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RabbitmqFieldsNameEnum.PASSWORD}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.PASSWORD)}`,
     },
   },
   {
@@ -83,30 +82,30 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     label: '',
     renderComponentContent: () => ({
-      default: () => RabbitmqFieldsNameEnum.AUTOMATIC_RECOVERY_ENABLED,
+      default: () => t(RabbitmqFieldsNameEnum.AUTOMATIC_RECOVERY_ENABLED),
     }),
   },
   {
     field: RabbitmqFieldsEnum.CONNECTION_TIMEOUT,
-    label: h('span', t(RabbitmqFieldsNameEnum.CONNECTION_TIMEOUT)),
+    label: t(RabbitmqFieldsNameEnum.CONNECTION_TIMEOUT),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${RabbitmqFieldsNameEnum.CONNECTION_TIMEOUT}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.CONNECTION_TIMEOUT)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.HANDSHAKE_TIMEOUT,
-    label: h('span', t(RabbitmqFieldsNameEnum.HANDSHAKE_TIMEOUT)),
+    label: t(RabbitmqFieldsNameEnum.HANDSHAKE_TIMEOUT),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${RabbitmqFieldsNameEnum.HANDSHAKE_TIMEOUT}`,
+      placeholder: `请输入${t(RabbitmqFieldsNameEnum.HANDSHAKE_TIMEOUT)}`,
     },
   },
   {
     field: RabbitmqFieldsEnum.CLIENT_PROPERTIES,
-    label: h('span', t(RabbitmqFieldsNameEnum.CLIENT_PROPERTIES)),
+    label: t(RabbitmqFieldsNameEnum.CLIENT_PROPERTIES),
     component: 'Input',
     slot: RabbitmqFieldsEnum.CLIENT_PROPERTIES,
   },

-import { h } from 'vue';
 import { ProtocolEnum, ProtocolNameEnum, RequestMethodEnum } from '../../../enum/form';
 import { RestApiCallFieldsEnum, RestApiCallFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
@@ -9,24 +8,24 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: RestApiCallFieldsEnum.REST_ENDPOINT_URL_PATTERN,
-    label: h('span', t(RestApiCallFieldsNameEnum.REST_ENDPOINT_URL_PATTERN)),
+    label: t(RestApiCallFieldsNameEnum.REST_ENDPOINT_URL_PATTERN),
     component: 'Input',
     required: true,
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     componentProps: {
-      placeholder: `请输入${RestApiCallFieldsNameEnum.REST_ENDPOINT_URL_PATTERN}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.REST_ENDPOINT_URL_PATTERN)}`,
     },
   },
   {
     field: RestApiCallFieldsEnum.REQUEST_METHOD,
-    label: h('span', t(RestApiCallFieldsNameEnum.REQUEST_METHOD)),
+    label: t(RestApiCallFieldsNameEnum.REQUEST_METHOD),
     component: 'Select',
     required: true,
     componentProps: {
       options: Object.keys(RequestMethodEnum).map((value) => ({ label: value, value })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${RestApiCallFieldsNameEnum.REQUEST_METHOD}`,
+      placeholder: `请选择${t(RestApiCallFieldsNameEnum.REQUEST_METHOD)}`,
     },
   },
   {
@@ -34,7 +33,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.ENABLE_PROXY,
+      default: () => t(RestApiCallFieldsNameEnum.ENABLE_PROXY),
     }),
   },
   {
@@ -43,7 +42,7 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     show: ({ model }) => !model[RestApiCallFieldsEnum.ENABLE_PROXY],
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.USE_SIMPLE_CLIENT_HTTP_FACTORY,
+      default: () => t(RestApiCallFieldsNameEnum.USE_SIMPLE_CLIENT_HTTP_FACTORY),
     }),
   },
   {
@@ -51,7 +50,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.IGNORE_REQUEST_BODY,
+      default: () => t(RestApiCallFieldsNameEnum.IGNORE_REQUEST_BODY),
     }),
   },
   {
@@ -60,12 +59,12 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     show: ({ model }) => model[RestApiCallFieldsEnum.ENABLE_PROXY],
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.USE_SYSTEM_PROXY_PROPERTIES,
+      default: () => t(RestApiCallFieldsNameEnum.USE_SYSTEM_PROXY_PROPERTIES),
     }),
   },
   {
     field: RestApiCallFieldsEnum.PROXY_SCHEME,
-    label: h('span', t(RestApiCallFieldsNameEnum.PROXY_SCHEME)),
+    label: t(RestApiCallFieldsNameEnum.PROXY_SCHEME),
     component: 'Select',
     required: true,
     colProps: { span: 8 },
@@ -75,7 +74,7 @@ export const formSchemas: FormSchema[] = [
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${RestApiCallFieldsEnum.PROXY_SCHEME}`,
+      placeholder: `请选择${t(RestApiCallFieldsEnum.PROXY_SCHEME)}`,
     },
     ifShow: ({ model }) => {
       const ifShowField = model[RestApiCallFieldsEnum.ENABLE_PROXY];
@@ -84,12 +83,12 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: RestApiCallFieldsEnum.PROXY_HOST,
-    label: h('span', t(RestApiCallFieldsNameEnum.PROXY_HOST)),
+    label: t(RestApiCallFieldsNameEnum.PROXY_HOST),
     component: 'Input',
     required: true,
     colProps: { span: 8 },
     componentProps: {
-      placeholder: `请输入${RestApiCallFieldsNameEnum.PROXY_HOST}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.PROXY_HOST)}`,
     },
     ifShow: ({ model }) => {
       const ifShowField = model[RestApiCallFieldsEnum.ENABLE_PROXY];
@@ -98,12 +97,12 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: RestApiCallFieldsEnum.PROXY_PORT,
-    label: h('span', t(RestApiCallFieldsNameEnum.PROXY_PORT)),
+    label: t(RestApiCallFieldsNameEnum.PROXY_PORT),
     component: 'InputNumber',
     required: true,
     colProps: { span: 8 },
     componentProps: {
-      placeholder: `请输入${RestApiCallFieldsNameEnum.PROXY_HOST}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.PROXY_HOST)}`,
     },
     ifShow: ({ model }) => {
       const ifShowField = model[RestApiCallFieldsEnum.ENABLE_PROXY];
@@ -112,10 +111,10 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: RestApiCallFieldsEnum.PROXY_USER,
-    label: h('span', t(RestApiCallFieldsNameEnum.PROXY_USER)),
+    label: t(RestApiCallFieldsNameEnum.PROXY_USER),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RestApiCallFieldsNameEnum.PROXY_USER}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.PROXY_USER)}`,
     },
     ifShow: ({ model }) => {
       const ifShowField = model[RestApiCallFieldsEnum.ENABLE_PROXY];
@@ -124,10 +123,10 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: RestApiCallFieldsEnum.PROXY_PASSWORD,
-    label: h('span', t(RestApiCallFieldsNameEnum.PROXY_PASSWORD)),
+    label: t(RestApiCallFieldsNameEnum.PROXY_PASSWORD),
     component: 'Input',
     componentProps: {
-      placeholder: `请输入${RestApiCallFieldsNameEnum.PROXY_PASSWORD}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.PROXY_PASSWORD)}`,
     },
     ifShow: ({ model }) => {
       const ifShowField = model[RestApiCallFieldsEnum.ENABLE_PROXY];
@@ -136,25 +135,25 @@ export const formSchemas: FormSchema[] = [
   },
   {
     field: RestApiCallFieldsEnum.READ_TIMEOUT_MS,
-    label: h('span', t(RestApiCallFieldsNameEnum.READ_TIMEOUT_MS)),
+    label: t(RestApiCallFieldsNameEnum.READ_TIMEOUT_MS),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${RestApiCallFieldsNameEnum.READ_TIMEOUT_MS}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.READ_TIMEOUT_MS)}`,
     },
   },
   {
     field: RestApiCallFieldsEnum.MAX_PARALLEL_REQUESTS_COUNT,
-    label: h('span', t(RestApiCallFieldsNameEnum.MAX_PARALLEL_REQUESTS_COUNT)),
+    label: t(RestApiCallFieldsNameEnum.MAX_PARALLEL_REQUESTS_COUNT),
     component: 'InputNumber',
     componentProps: {
       min: 0,
-      placeholder: `请输入${RestApiCallFieldsNameEnum.MAX_PARALLEL_REQUESTS_COUNT}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.MAX_PARALLEL_REQUESTS_COUNT)}`,
     },
   },
   {
     field: RestApiCallFieldsEnum.HEADERS,
-    label: h('span', t(RestApiCallFieldsNameEnum.HEADERS)),
+    label: t(RestApiCallFieldsNameEnum.HEADERS),
     component: 'Input',
     slot: RestApiCallFieldsEnum.HEADERS,
   },
@@ -163,7 +162,7 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE,
+      default: () => t(RestApiCallFieldsNameEnum.USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE),
     }),
   },
   {
@@ -172,22 +171,22 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     ifShow: ({ model }) => model[RestApiCallFieldsEnum.USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE],
     renderComponentContent: () => ({
-      default: () => RestApiCallFieldsNameEnum.TRIM_QUEUE,
+      default: () => t(RestApiCallFieldsNameEnum.TRIM_QUEUE),
     }),
   },
   {
     field: RestApiCallFieldsEnum.MAX_QUEUE_SIZE,
-    label: h('span', t(RestApiCallFieldsNameEnum.MAX_QUEUE_SIZE)),
+    label: t(RestApiCallFieldsNameEnum.MAX_QUEUE_SIZE),
     component: 'InputNumber',
     ifShow: ({ model }) => model[RestApiCallFieldsEnum.USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE],
     componentProps: {
       min: 0,
-      placeholder: `请输入${RestApiCallFieldsNameEnum.MAX_QUEUE_SIZE}`,
+      placeholder: `请输入${t(RestApiCallFieldsNameEnum.MAX_QUEUE_SIZE)}`,
     },
   },
   {
     field: RestApiCallFieldsEnum.CREDENTIALS,
-    label: h('span', t(RestApiCallFieldsNameEnum.CREDENTIALS)),
+    label: t(RestApiCallFieldsNameEnum.CREDENTIALS),
     component: 'Input',
     slot: RestApiCallFieldsEnum.CREDENTIALS,
   },

-import { h } from 'vue';
 import {
   EmailProtocolEnum,
   EmailProtocolNameEnum,
@@ -17,12 +16,12 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => SendEmailFieldsNameEnum.USE_SYSTEM_SMTP_SETTINGS,
+      default: () => t(SendEmailFieldsNameEnum.USE_SYSTEM_SMTP_SETTINGS),
     }),
   },
   {
     field: SendEmailFieldsEnum.SMTP_PROTOCOL,
-    label: h('span', t(SendEmailFieldsNameEnum.SMTP_PROTOCOL)),
+    label: t(SendEmailFieldsNameEnum.SMTP_PROTOCOL),
     component: 'Select',
     required: true,
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
@@ -31,42 +30,42 @@ export const formSchemas: FormSchema[] = [
         label: EmailProtocolNameEnum[value],
         value,
       })),
-      placeholder: `请选择${SendEmailFieldsNameEnum.SMTP_PROTOCOL}`,
+      placeholder: `请选择${t(SendEmailFieldsNameEnum.SMTP_PROTOCOL)}`,
       getPopupContainer: () => document.body,
     },
   },
   {
     field: SendEmailFieldsEnum.SMTP_HOST,
-    label: h('span', t(SendEmailFieldsNameEnum.SMTP_HOST)),
+    label: t(SendEmailFieldsNameEnum.SMTP_HOST),
     component: 'Input',
     required: true,
     colProps: { span: 12 },
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.SMTP_HOST}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.SMTP_HOST)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.SMTP_PORT,
-    label: h('span', t(SendEmailFieldsNameEnum.SMTP_PORT)),
+    label: t(SendEmailFieldsNameEnum.SMTP_PORT),
     component: 'InputNumber',
     required: true,
     colProps: { span: 12 },
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     componentProps: {
       min: 0,
-      placeholder: `请输入${SendEmailFieldsNameEnum.SMTP_PORT}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.SMTP_PORT)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.TIMEOUT,
-    label: h('span', t(SendEmailFieldsNameEnum.TIMEOUT)),
+    label: t(SendEmailFieldsNameEnum.TIMEOUT),
     component: 'InputNumber',
     required: true,
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     componentProps: {
       min: 0,
-      placeholder: `请输入${SendEmailFieldsNameEnum.TIMEOUT}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.TIMEOUT)}`,
     },
   },
   {
@@ -75,12 +74,12 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     renderComponentContent: () => ({
-      default: () => SendEmailFieldsNameEnum.ENABLE_TLS,
+      default: () => t(SendEmailFieldsNameEnum.ENABLE_TLS),
     }),
   },
   {
     field: SendEmailFieldsEnum.TLS_VERSION,
-    label: h('span', t(SendEmailFieldsNameEnum.TLS_VERSION)),
+    label: t(SendEmailFieldsNameEnum.TLS_VERSION),
     component: 'Select',
     required: true,
     ifShow: ({ model }) =>
@@ -90,7 +89,7 @@ export const formSchemas: FormSchema[] = [
         label: TSLVersionNameEnum[value],
         value,
       })),
-      placeholder: `请选择${SendEmailFieldsNameEnum.TLS_VERSION}`,
+      placeholder: `请选择${t(SendEmailFieldsNameEnum.TLS_VERSION)}`,
       getPopupContainer: () => document.body,
     },
   },
@@ -100,12 +99,12 @@ export const formSchemas: FormSchema[] = [
     component: 'Checkbox',
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     renderComponentContent: () => ({
-      default: () => SendEmailFieldsNameEnum.ENABLE_PROXY,
+      default: () => t(SendEmailFieldsNameEnum.ENABLE_PROXY),
     }),
   },
   {
     field: SendEmailFieldsEnum.PROXY_HOST,
-    label: h('span', t(SendEmailFieldsNameEnum.PROXY_HOST)),
+    label: t(SendEmailFieldsNameEnum.PROXY_HOST),
     component: 'Input',
     required: true,
     colProps: { span: 12 },
@@ -113,12 +112,12 @@ export const formSchemas: FormSchema[] = [
       !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS] &&
       model[SendEmailFieldsEnum.ENABLE_PROXY],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.PROXY_HOST}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.PROXY_HOST)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.PROXY_PORT,
-    label: h('span', t(SendEmailFieldsNameEnum.PROXY_PORT)),
+    label: t(SendEmailFieldsNameEnum.PROXY_PORT),
     component: 'Input',
     required: true,
     colProps: { span: 12 },
@@ -126,47 +125,47 @@ export const formSchemas: FormSchema[] = [
       !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS] &&
       model[SendEmailFieldsEnum.ENABLE_PROXY],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.PROXY_PORT}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.PROXY_PORT)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.PROXY_USER,
-    label: h('span', t(SendEmailFieldsNameEnum.PROXY_USER)),
+    label: t(SendEmailFieldsNameEnum.PROXY_USER),
     component: 'Input',
     ifShow: ({ model }) =>
       !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS] &&
       model[SendEmailFieldsEnum.ENABLE_PROXY],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.PROXY_USER}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.PROXY_USER)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.PROXY_PASSWORD,
-    label: h('span', t(SendEmailFieldsNameEnum.PROXY_PASSWORD)),
+    label: t(SendEmailFieldsNameEnum.PROXY_PASSWORD),
     component: 'Input',
     ifShow: ({ model }) =>
       !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS] &&
       model[SendEmailFieldsEnum.ENABLE_PROXY],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.PROXY_PASSWORD}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.PROXY_PASSWORD)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.USERNAME,
-    label: h('span', t(SendEmailFieldsNameEnum.USERNAME)),
+    label: t(SendEmailFieldsNameEnum.USERNAME),
     component: 'Input',
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.USERNAME}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.USERNAME)}`,
     },
   },
   {
     field: SendEmailFieldsEnum.PASSWORD,
-    label: h('span', t(SendEmailFieldsNameEnum.PASSWORD)),
+    label: t(SendEmailFieldsNameEnum.PASSWORD),
     component: 'InputPassword',
     ifShow: ({ model }) => !model[SendEmailFieldsEnum.USE_SYSTEM_SMTP_SETTINGS],
     componentProps: {
-      placeholder: `请输入${SendEmailFieldsNameEnum.PASSWORD}`,
+      placeholder: `请输入${t(SendEmailFieldsNameEnum.PASSWORD)}`,
     },
   },
 ];

-import { h } from 'vue';
 import { SMSServiceProviderEnum, SMSServiceProviderNameEnum } from '../../../enum/form';
 import { SendSMSFieldsEnum, SendSMSFieldsNameEnum } from '../../../enum/formField/external';
 import { FormSchema } from '/@/components/Form';
@@ -9,24 +8,24 @@ const { t } = useI18n();
 export const formSchemas: FormSchema[] = [
   {
     field: SendSMSFieldsEnum.NUMBERS_TO_TEMPLATE,
-    label: h('span', t(SendSMSFieldsNameEnum.NUMBERS_TO_TEMPLATE)),
+    label: t(SendSMSFieldsNameEnum.NUMBERS_TO_TEMPLATE),
     component: 'Input',
     required: true,
     helpMessage:
       'Comma separated Phone Numbers, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     componentProps: {
-      placeholder: `请输入${SendSMSFieldsNameEnum.NUMBERS_TO_TEMPLATE}`,
+      placeholder: `请输入${t(SendSMSFieldsNameEnum.NUMBERS_TO_TEMPLATE)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.SMS_MESSAGE_TEMPLATE,
-    label: h('span', t(SendSMSFieldsNameEnum.SMS_MESSAGE_TEMPLATE)),
+    label: t(SendSMSFieldsNameEnum.SMS_MESSAGE_TEMPLATE),
     component: 'InputTextArea',
     required: true,
     helpMessage:
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     componentProps: {
-      placeholder: `请输入${SendSMSFieldsNameEnum.SMS_MESSAGE_TEMPLATE}`,
+      placeholder: `请输入${t(SendSMSFieldsNameEnum.SMS_MESSAGE_TEMPLATE)}`,
     },
   },
   {
@@ -34,12 +33,12 @@ export const formSchemas: FormSchema[] = [
     label: '',
     component: 'Checkbox',
     renderComponentContent: () => ({
-      default: () => SendSMSFieldsNameEnum.USE_SYSTEM_SMS_SETTINGS,
+      default: () => t(SendSMSFieldsNameEnum.USE_SYSTEM_SMS_SETTINGS),
     }),
   },
   {
     field: SendSMSFieldsEnum.TYPE,
-    label: h('span', t(SendSMSFieldsNameEnum.TYPE)),
+    label: t(SendSMSFieldsNameEnum.TYPE),
     component: 'Select',
     required: true,
     ifShow: ({ model }) => !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS],
@@ -49,12 +48,12 @@ export const formSchemas: FormSchema[] = [
         value,
       })),
       getPopupContainer: () => document.body,
-      placeholder: `请选择${SendSMSFieldsNameEnum.TYPE}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.TYPE)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.NUMBER_FROM,
-    label: h('span', t(SendSMSFieldsNameEnum.NUMBER_FROM)),
+    label: t(SendSMSFieldsNameEnum.NUMBER_FROM),
     component: 'Input',
     required: true,
     helpMessage: `Phone Number in E.164 format/Phone Number's SID/Messaging Service SID, ex. +19995550123/PNXXX/MGXXX`,
@@ -62,67 +61,67 @@ export const formSchemas: FormSchema[] = [
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.TWILIO,
     componentProps: {
-      placeholder: `请输入${SendSMSFieldsNameEnum.NUMBER_FROM}`,
+      placeholder: `请输入${t(SendSMSFieldsNameEnum.NUMBER_FROM)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.ACCOUNT_SID,
-    label: h('span', t(SendSMSFieldsNameEnum.ACCOUNT_SID)),
+    label: t(SendSMSFieldsNameEnum.ACCOUNT_SID),
     component: 'Input',
     required: true,
     ifShow: ({ model }) =>
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.TWILIO,
     componentProps: {
-      placeholder: `请选择${SendSMSFieldsNameEnum.ACCOUNT_SID}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.ACCOUNT_SID)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.ACCOUNT_TOKEN,
-    label: h('span', t(SendSMSFieldsNameEnum.ACCOUNT_TOKEN)),
+    label: t(SendSMSFieldsNameEnum.ACCOUNT_TOKEN),
     component: 'Input',
     required: true,
     ifShow: ({ model }) =>
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.TWILIO,
     componentProps: {
-      placeholder: `请选择${SendSMSFieldsNameEnum.ACCOUNT_TOKEN}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.ACCOUNT_TOKEN)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.ACCESS_KEY_ID,
-    label: h('span', t(SendSMSFieldsNameEnum.ACCESS_KEY_ID)),
+    label: t(SendSMSFieldsNameEnum.ACCESS_KEY_ID),
     component: 'Input',
     required: true,
     ifShow: ({ model }) =>
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.AWS_SNS,
     componentProps: {
-      placeholder: `请选择${SendSMSFieldsNameEnum.ACCESS_KEY_ID}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.ACCESS_KEY_ID)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.SECRET_ACCESS_KEY,
-    label: h('span', t(SendSMSFieldsNameEnum.SECRET_ACCESS_KEY)),
+    label: t(SendSMSFieldsNameEnum.SECRET_ACCESS_KEY),
     component: 'InputPassword',
     required: true,
     ifShow: ({ model }) =>
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.AWS_SNS,
     componentProps: {
-      placeholder: `请选择${SendSMSFieldsNameEnum.SECRET_ACCESS_KEY}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.SECRET_ACCESS_KEY)}`,
     },
   },
   {
     field: SendSMSFieldsEnum.REGION,
-    label: h('span', t(SendSMSFieldsNameEnum.REGION)),
+    label: t(SendSMSFieldsNameEnum.REGION),
     component: 'InputPassword',
     required: true,
     ifShow: ({ model }) =>
       !model[SendSMSFieldsEnum.USE_SYSTEM_SMS_SETTINGS] &&
       model[SendSMSFieldsEnum.TYPE] === SMSServiceProviderEnum.AWS_SNS,
     componentProps: {
-      placeholder: `请选择${SendSMSFieldsNameEnum.REGION}`,
+      placeholder: `请选择${t(SendSMSFieldsNameEnum.REGION)}`,
     },
   },
 ];

@@ -7,13 +7,12 @@ import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
 import { AlarmStatus, AlarmStatusMean } from '/@/enums/alarmEnum';
-import { h } from 'vue';
 
 export const formSchemas: FormSchema[] = [
   {
     field: CheckAlarmStatusFieldEnum.ALARM_STATUS_LIST,
     component: 'Select',
-    label: h('span', t(CheckAlarmStatusFieldNameEnum.ALARM_STATUS_LIST)),
+    label: t(CheckAlarmStatusFieldNameEnum.ALARM_STATUS_LIST),
     rules: [
       {
         required: true,

-import { h } from 'vue';
 import {
   CheckExistenceFieldsEnum,
   CheckExistenceFieldsNameEnum,
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CheckExistenceFieldsEnum.MESSAGE_NAMES,
     component: 'Select',
-    label: h('span', t(CheckExistenceFieldsNameEnum.MESSAGE_NAMES)),
+    label: t(CheckExistenceFieldsNameEnum.MESSAGE_NAMES),
     rules: [
       {
         required: true,
@@ -30,7 +29,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CheckExistenceFieldsEnum.METADATA_NAMES,
     component: 'Select',
-    label: h('span', t(CheckExistenceFieldsNameEnum.METADATA_NAMES)),
+    label: t(CheckExistenceFieldsNameEnum.METADATA_NAMES),
     rules: [
       {
         required: true,

@@ -26,7 +26,6 @@ import {
   getEntityEdge,
 } from '/@/api/ruleChainDesigner';
 import { useUserStore } from '/@/store/modules/user';
-import { h } from 'vue';
 
 export const getEntityIdSelect = (type: EntityTypeEnum) => {
   const method = {
@@ -51,7 +50,7 @@ export const getEntityIdSelect = (type: EntityTypeEnum) => {
   };
 
   return {
-    placeholder: `请选择${EntityTypeNameEnum[type] ?? ''}`,
+    placeholder: `请选择${t(EntityTypeNameEnum[type] ?? '')}`,
     resultField: 'data',
     labelField: 'name',
     valueField: 'id.id',
@@ -74,7 +73,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CheckRelationFieldsEnum.DIRECTION,
     component: 'Select',
-    label: h('span', t(CheckRelationFieldsNameEnum.DIRECTION)),
+    label: t(CheckRelationFieldsNameEnum.DIRECTION),
     componentProps: {
       options: [
         { label: DirectionNameEnum.FROM, value: DirectionEnum.FROM },
@@ -87,7 +86,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CheckRelationFieldsEnum.ENTITY_TYPE,
     component: 'Select',
-    label: h('span', t(CheckRelationFieldsNameEnum.ENTITY_TYPE)),
+    label: t(CheckRelationFieldsNameEnum.ENTITY_TYPE),
     colProps: { span: 8 },
     componentProps: ({ formActionType }) => {
       const { setFieldsValue } = formActionType;
@@ -120,7 +119,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: CheckRelationFieldsEnum.RELEATION_TYPE,
     component: 'Select',
-    label: h('span', t(CheckRelationFieldsNameEnum.RELEATION_TYPE)),
+    label: t(CheckRelationFieldsNameEnum.RELEATION_TYPE),
     defaultValue: RelationTypeEnum.CONTAINS,
     componentProps: {
       options: Object.keys(RelationTypeEnum).map((value) => ({

-import { h } from 'vue';
 import { PerimeterTypeEnum, RangeUtilEnum, RangeUtilNameEnum } from '../../../enum/form';
 import {
   GpsGeofencingFilterFieldsEnum,
@@ -13,7 +12,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.LATITUDE_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.LATITUDE_KEY_NAME)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.LATITUDE_KEY_NAME),
     componentProps: {
       placeholder: `请输入${t(GpsGeofencingFilterFieldsNameEnum.LATITUDE_KEY_NAME)}`,
     },
@@ -21,7 +20,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.LONGITUDE_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.LONGITUDE_KEY_NAME)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.LONGITUDE_KEY_NAME),
     componentProps: {
       placeholder: `请输入${t(GpsGeofencingFilterFieldsNameEnum.LONGITUDE_KEY_NAME)}`,
     },
@@ -29,7 +28,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.PERIMETER_TYPE,
     component: 'Select',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.PERIMETER_TYPE)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.PERIMETER_TYPE),
     componentProps: {
       options: Object.keys(PerimeterTypeEnum).map((value) => ({ label: value, value })),
       placeholder: `请选择${t(GpsGeofencingFilterFieldsNameEnum.PERIMETER_TYPE)}`,
@@ -47,7 +46,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.PERIMETER_KEY_NAME,
     component: 'Input',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.PERIMETER_KEY_NAME)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.PERIMETER_KEY_NAME),
     show: ({ model }) =>
       model[GpsGeofencingFilterFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
     componentProps: {
@@ -57,7 +56,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.POLYGONS_DEFINITION,
     component: 'Input',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.POLYGONS_DEFINITION)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.POLYGONS_DEFINITION),
     helpMessage:
       'Please, use the following format for manual definition of polygon: [[lat1,lon1],[lat2,lon2], ... ,[latN,lonN]].',
     show: ({ model }) =>
@@ -70,7 +69,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.CENTER_LATITUDE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.CENTER_LATITUDE)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.CENTER_LATITUDE),
     colProps: { span: 12 },
     show: ({ model }) =>
       model[GpsGeofencingFilterFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
@@ -82,7 +81,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.CENTER_LONGITUDE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.CENTER_LONGITUDE)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.CENTER_LONGITUDE),
     colProps: { span: 12 },
     show: ({ model }) =>
       model[GpsGeofencingFilterFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
@@ -94,7 +93,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.RANGE,
     component: 'InputNumber',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.RANGE)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.RANGE),
     colProps: { span: 12 },
     show: ({ model }) =>
       model[GpsGeofencingFilterFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
@@ -106,7 +105,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: GpsGeofencingFilterFieldsEnum.RANGE_UNIT,
     component: 'Select',
-    label: h('span', t(GpsGeofencingFilterFieldsNameEnum.RANGE_UNIT)),
+    label: t(GpsGeofencingFilterFieldsNameEnum.RANGE_UNIT),
     colProps: { span: 12 },
     show: ({ model }) =>
       model[GpsGeofencingFilterFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&

-import { h } from 'vue';
 import { MessageTypesEnum, MessageTypesNameEnum } from '../../../enum/form';
 import { MessageTypeFieldsEnum, MessageTypeFieldsNameEnum } from '../../../enum/formField/filter';
 import { FormSchema } from '/@/components/Form';
@@ -10,7 +9,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: MessageTypeFieldsEnum.MESSAGE_TYPES,
     component: 'Select',
-    label: h('span', t(MessageTypeFieldsNameEnum.MESSAGE_TYPES)),
+    label: t(MessageTypeFieldsNameEnum.MESSAGE_TYPES),
     componentProps: {
       options: Object.keys(MessageTypesEnum).map((value) => ({
         label: MessageTypesNameEnum[value],

@@ -8,13 +8,12 @@ import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
 import { DictEnum } from '/@/enums/dictEnum';
-import { h } from 'vue';
 
 export const formSchemas: FormSchema[] = [
   {
     field: OriginatorTypeFieldsEnum.ORIGINATOR_TYPES,
     component: 'ApiSelect',
-    label: h('span', t(OriginatorTypeFieldsNameEnum.ORIGINATOR_TYPES)),
+    label: t(OriginatorTypeFieldsNameEnum.ORIGINATOR_TYPES),
     componentProps: {
       api: findDictItemByCode,
       params: {

-import { h } from 'vue';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import HelpMessage from './HelpMessage.vue';
 import { JavascriptEditorWithTestModal } from '/@/views/rule/designer/src/components/JavaScriptFilterModal';
@@ -13,7 +12,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ScriptFieldsEnum.JS_SCRIPT,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(ScriptFieldsNameEnum.JS_SCRIPT)),
+    label: t(ScriptFieldsNameEnum.JS_SCRIPT),
     changeEvent: 'update:value',
     valueField: 'value',
     renderComponentContent: () => {

-import { h } from 'vue';
 import { SwitchFieldsEnum, SwitchFieldsNameEnum } from '../../../enum/formField/filter';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { JavascriptEditorWithTestModal } from '/@/views/rule/designer/src/components/JavaScriptFilterModal';
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: SwitchFieldsEnum.JS_SCRIPT,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(SwitchFieldsNameEnum.JS_SCRIPT)),
+    label: t(SwitchFieldsNameEnum.JS_SCRIPT),
     changeEvent: 'update:value',
     valueField: 'value',
     componentProps: {

@@ -2,7 +2,7 @@ import { CheckPointFieldsEnum, CheckPointFieldsNameEnum } from '../../../enum/fo
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import ApiComplete from './ApiComplete.vue';
 import { getTenantQueue } from '/@/api/ruleChainDesigner';
-import { h } from 'vue';
+
 import { useI18n } from '/@/hooks/web/useI18n';
 
 const { t } = useI18n();
@@ -12,7 +12,7 @@ useComponentRegister('ApiComplete', ApiComplete);
 export const formSchemas: FormSchema[] = [
   {
     field: CheckPointFieldsEnum.QUEUE_NAME,
-    label: h('span', t(CheckPointFieldsNameEnum.QUEUE_NAME)),
+    label: t(CheckPointFieldsNameEnum.QUEUE_NAME),
     component: 'ApiComplete',
     required: true,
     helpMessage: ['从下拉列表中选择或自定义名称'],
@@ -20,7 +20,7 @@ export const formSchemas: FormSchema[] = [
     changeEvent: 'update:value',
     componentProps: () => {
       return {
-        placeholder: `请选择${CheckPointFieldsNameEnum.QUEUE_NAME}`,
+        placeholder: `请选择${t(CheckPointFieldsNameEnum.QUEUE_NAME)}`,
         getPopupContainer: () => document.body,
         api: async (params: Recordable) => {
           const options = await getTenantQueue(params);

@@ -3,7 +3,6 @@ import { RuleChainFieldsEnum, RuleChainFieldsNameEnum } from '../../../enum/form
 import { getRuleChains } from '/@/api/ruleDesigner';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
-import { h } from 'vue';
 
 const { t } = useI18n();
 
@@ -26,7 +25,7 @@ export const getFormSchemas = (route: RouteLocationNormalizedLoaded): FormSchema
   return [
     {
       field: RuleChainFieldsEnum.RULE_CHAIN_ID,
-      label: h('span', t(RuleChainFieldsNameEnum.RULE_CHAIN_ID)),
+      label: t(RuleChainFieldsNameEnum.RULE_CHAIN_ID),
       component: 'ApiSearchSelect',
       componentProps: () => {
         return {

-import { h } from 'vue';
 import { OriginatorSourceEnum, OriginatorSourceNameEnum } from '../../../enum/form';
 import {
   ChangeOriginatorFieldsEnum,
@@ -16,7 +15,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ChangeOriginatorFieldsEnum.ORIGINATOR_SOURCE,
     component: 'Select',
-    label: h('span', t(ChangeOriginatorFieldsNameEnum.ORIGINATOR_SOURCE)),
+    label: t(ChangeOriginatorFieldsNameEnum.ORIGINATOR_SOURCE),
     rules: [
       { required: true, message: `请选择${t(ChangeOriginatorFieldsNameEnum.ORIGINATOR_SOURCE)}` },
     ],
@@ -32,7 +31,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ChangeOriginatorFieldsEnum.RELATIONS_QUERY,
     component: 'RelationsQuery',
-    label: h('span', t(ChangeOriginatorFieldsNameEnum.RELATIONS_QUERY)),
+    label: t(ChangeOriginatorFieldsNameEnum.RELATIONS_QUERY),
     slot: ChangeOriginatorFieldsEnum.RELATIONS_QUERY,
     ifShow: ({ model }) =>
       model[ChangeOriginatorFieldsEnum.ORIGINATOR_SOURCE] === OriginatorSourceEnum.RELATED,

-import { h } from 'vue';
 import { ScriptFieldsEnum, ScriptFieldsNameEnum } from '../../../enum/formField/transformation';
 import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
@@ -12,7 +11,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ScriptFieldsEnum.JS_SCRIPT,
     component: 'JavascriptEditorWithTestModal',
-    label: h('span', t(ScriptFieldsNameEnum.JS_SCRIPT)),
+    label: t(ScriptFieldsNameEnum.JS_SCRIPT),
     changeEvent: 'update:value',
     valueField: 'value',
     componentProps: {

-import { h } from 'vue';
 import { MailBodyTypeEnum, MailBodyTypeNameEnum } from '../../../enum/form';
 import { ToEmailFieldsEnum, ToEmailFieldsNameEnum } from '../../../enum/formField/transformation';
 import { FormSchema } from '/@/components/Form';
@@ -10,7 +9,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.FROM_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.FROM_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.FROM_TEMPLATE),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -21,7 +20,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.TO_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.TO_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.TO_TEMPLATE),
     helpMessage: [
       'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -32,7 +31,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.CC_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.CC_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.CC_TEMPLATE),
     helpMessage: [
       'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -43,7 +42,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.BCC_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.BCC_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.BCC_TEMPLATE),
     helpMessage: [
       'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -54,7 +53,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.SUBJECT_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.SUBJECT_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.SUBJECT_TEMPLATE),
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
     ],
@@ -65,7 +64,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.MAIL_BODY_TYPE,
     component: 'Select',
-    label: h('span', t(ToEmailFieldsNameEnum.MAIL_BODY_TYPE)),
+    label: t(ToEmailFieldsNameEnum.MAIL_BODY_TYPE),
     componentProps: ({ formActionType }) => {
       const { setFieldsValue } = formActionType;
       return {
@@ -85,7 +84,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.IS_HTML_TEMPLATE,
     component: 'Input',
-    label: h('span', t(ToEmailFieldsNameEnum.IS_HTML_TEMPLATE)),
+    label: t(ToEmailFieldsNameEnum.IS_HTML_TEMPLATE),
     show: ({ model }) => model[ToEmailFieldsEnum.MAIL_BODY_TYPE] === MailBodyTypeEnum.DYNAMIC,
     helpMessage: [
       'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
@@ -97,7 +96,7 @@ export const formSchemas: FormSchema[] = [
   {
     field: ToEmailFieldsEnum.BODY_TEMPLATE,
     component: 'InputTextArea',
-    label: h('span', t(ToEmailFieldsEnum.BODY_TEMPLATE)),
+    label: t(ToEmailFieldsEnum.BODY_TEMPLATE),
     componentProps: {
       placeholder: `请输入${t(ToEmailFieldsNameEnum.BODY_TEMPLATE)}`,
       autoSize: { minRows: 3 },

-import { h } from 'vue';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema } from '/@/components/Form';
 import { useI18n } from '/@/hooks/web/useI18n';
@@ -9,7 +8,7 @@ export const TopFormSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.NAME,
     component: 'Input',
-    label: h('span', t(NodeBindDataFieldNameEnum.NAME)),
+    label: t(NodeBindDataFieldNameEnum.NAME),
     colProps: {
       span: 16,
     },
@@ -21,7 +20,7 @@ export const TopFormSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.DEBUG_MODE,
     component: 'Switch',
-    label: h('span', t(NodeBindDataFieldNameEnum.DEBUG_MODE)),
+    label: t(NodeBindDataFieldNameEnum.DEBUG_MODE),
     colProps: {
       offset: 2,
       span: 6,
@@ -41,7 +40,7 @@ export const BottomFormSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.DESCRIPTION,
     component: 'InputTextArea',
-    label: h('span', t(NodeBindDataFieldNameEnum.DESCRIPTION)),
+    label: t(NodeBindDataFieldNameEnum.DESCRIPTION),
     componentProps: {
       placeholder: `请输入${t(NodeBindDataFieldNameEnum.DESCRIPTION)}`,
       autoSize: true,

@@ -67,6 +67,7 @@
   <BasicModal
     v-model:visible="visible"
     :title="`添加规则节点: ${nodeData?.config?.name}`"
+    width="50%"
     :get-container="getContainer"
     @ok="handleModalOk"
     @cancel="handleCancel"