@lcap/nasl 3.6.0-beta.1 → 3.7.0-beta.1

package/src/concepts/utils/asserts.ts

@@ -24,11 +24,25 @@ import type { BindAttribute } from '../BindAttribute__';
 import type { BindDirective } from '../BindDirective__';
 import type { BindEvent } from '../BindEvent__';
 import type { BindStyle } from '../BindStyle__';
-import type { ViewComponent } from '../ViewComponent__';
+import type { ThemeVariable } from '../ThemeVariable__';
+import type { BaseSetter } from '../BaseSetter__';
+import type { InputSetter } from '../InputSetter__';
+import type { SwitchSetter } from '../SwitchSetter__';
+import type { SetterOption } from '../SetterOption__';
+import type { EnumSelectSetter } from '../EnumSelectSetter__';
+import type { CapsulesSetter } from '../CapsulesSetter__';
+import type { NumberInputSetter } from '../NumberInputSetter__';
+import type { IconSetter } from '../IconSetter__';
+import type { ImageSetter } from '../ImageSetter__';
+import type { PropertySelectSetter } from '../PropertySelectSetter__';
+import type { ViewComponentDeclaration } from '../ViewComponentDeclaration__';
 import type { BusinessComponent } from '../BusinessComponent__';
 import type { Attribute } from '../Attribute__';
 import type { Event } from '../Event__';
-import type { Slot } from '../Slot__';
+import type { PropDeclaration } from '../PropDeclaration__';
+import type { EventDeclaration } from '../EventDeclaration__';
+import type { SlotDeclaration } from '../SlotDeclaration__';
+import type { LogicDeclaration } from '../LogicDeclaration__';
 import type { Theme } from '../Theme__';
 import type { Logic } from '../Logic__';
 import type { AuthLogic } from '../AuthLogic__';
@@ -126,6 +140,7 @@ import type { SelectMembers } from '../SelectMembers__';
 import type { AssignmentLine } from '../AssignmentLine__';
 import type { FrontendLibrary } from '../FrontendLibrary__';
 import type { ViewBlock } from '../ViewBlock__';
+import type { ViewBlockWithImage } from '../ViewBlockWithImage__';
 import type { AuthInterface } from '../AuthInterface__';
 import type { CallAuthInterface } from '../CallAuthInterface__';
 import type { TriggerEvent } from '../TriggerEvent__';
@@ -565,18 +580,168 @@ export function isStrictBindStyle(node: unknown): node is BindStyle {
 }
 
 /**
- * 严格判断输入为 ViewComponent 节点
+ * 严格判断输入为 ThemeVariable 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictViewComponent(node)) {
- *   // 在这个花括号内，node 的类型为 ViewComponent
+ * if (isStrictThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型为 ThemeVariable
  * }
  * ```
  */
-export function isStrictViewComponent(node: unknown): node is ViewComponent {
-  return isBaseNode(node) && node.concept === 'ViewComponent';
+export function isStrictThemeVariable(node: unknown): node is ThemeVariable {
+  return isBaseNode(node) && node.concept === 'ThemeVariable';
+}
+
+/**
+ * 严格判断输入为 InputSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 InputSetter
+ * }
+ * ```
+ */
+export function isStrictInputSetter(node: unknown): node is InputSetter {
+  return isBaseNode(node) && node.concept === 'InputSetter';
+}
+
+/**
+ * 严格判断输入为 SwitchSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSwitchSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 SwitchSetter
+ * }
+ * ```
+ */
+export function isStrictSwitchSetter(node: unknown): node is SwitchSetter {
+  return isBaseNode(node) && node.concept === 'SwitchSetter';
+}
+
+/**
+ * 严格判断输入为 SetterOption 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSetterOption(node)) {
+ *   // 在这个花括号内，node 的类型为 SetterOption
+ * }
+ * ```
+ */
+export function isStrictSetterOption(node: unknown): node is SetterOption {
+  return isBaseNode(node) && node.concept === 'SetterOption';
+}
+
+/**
+ * 严格判断输入为 EnumSelectSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictEnumSelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 EnumSelectSetter
+ * }
+ * ```
+ */
+export function isStrictEnumSelectSetter(node: unknown): node is EnumSelectSetter {
+  return isBaseNode(node) && node.concept === 'EnumSelectSetter';
+}
+
+/**
+ * 严格判断输入为 CapsulesSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 CapsulesSetter
+ * }
+ * ```
+ */
+export function isStrictCapsulesSetter(node: unknown): node is CapsulesSetter {
+  return isBaseNode(node) && node.concept === 'CapsulesSetter';
+}
+
+/**
+ * 严格判断输入为 NumberInputSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 NumberInputSetter
+ * }
+ * ```
+ */
+export function isStrictNumberInputSetter(node: unknown): node is NumberInputSetter {
+  return isBaseNode(node) && node.concept === 'NumberInputSetter';
+}
+
+/**
+ * 严格判断输入为 IconSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 IconSetter
+ * }
+ * ```
+ */
+export function isStrictIconSetter(node: unknown): node is IconSetter {
+  return isBaseNode(node) && node.concept === 'IconSetter';
+}
+
+/**
+ * 严格判断输入为 ImageSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 ImageSetter
+ * }
+ * ```
+ */
+export function isStrictImageSetter(node: unknown): node is ImageSetter {
+  return isBaseNode(node) && node.concept === 'ImageSetter';
+}
+
+/**
+ * 严格判断输入为 PropertySelectSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictPropertySelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 PropertySelectSetter
+ * }
+ * ```
+ */
+export function isStrictPropertySelectSetter(node: unknown): node is PropertySelectSetter {
+  return isBaseNode(node) && node.concept === 'PropertySelectSetter';
+}
+
+/**
+ * 严格判断输入为 ViewComponentDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 ViewComponentDeclaration
+ * }
+ * ```
+ */
+export function isStrictViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration {
+  return isBaseNode(node) && node.concept === 'ViewComponentDeclaration';
 }
 
 /**
@@ -625,18 +790,63 @@ export function isStrictEvent(node: unknown): node is Event {
 }
 
 /**
- * 严格判断输入为 Slot 节点
+ * 严格判断输入为 PropDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictSlot(node)) {
- *   // 在这个花括号内，node 的类型为 Slot
+ * if (isStrictPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 PropDeclaration
  * }
  * ```
  */
-export function isStrictSlot(node: unknown): node is Slot {
-  return isBaseNode(node) && node.concept === 'Slot';
+export function isStrictPropDeclaration(node: unknown): node is PropDeclaration {
+  return isBaseNode(node) && node.concept === 'PropDeclaration';
+}
+
+/**
+ * 严格判断输入为 EventDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 EventDeclaration
+ * }
+ * ```
+ */
+export function isStrictEventDeclaration(node: unknown): node is EventDeclaration {
+  return isBaseNode(node) && node.concept === 'EventDeclaration';
+}
+
+/**
+ * 严格判断输入为 SlotDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 SlotDeclaration
+ * }
+ * ```
+ */
+export function isStrictSlotDeclaration(node: unknown): node is SlotDeclaration {
+  return isBaseNode(node) && node.concept === 'SlotDeclaration';
+}
+
+/**
+ * 严格判断输入为 LogicDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 LogicDeclaration
+ * }
+ * ```
+ */
+export function isStrictLogicDeclaration(node: unknown): node is LogicDeclaration {
+  return isBaseNode(node) && node.concept === 'LogicDeclaration';
 }
 
 /**
@@ -2034,6 +2244,21 @@ export function isStrictViewBlock(node: unknown): node is ViewBlock {
   return isBaseNode(node) && node.concept === 'ViewBlock';
 }
 
+/**
+ * 严格判断输入为 ViewBlockWithImage 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictViewBlockWithImage(node)) {
+ *   // 在这个花括号内，node 的类型为 ViewBlockWithImage
+ * }
+ * ```
+ */
+export function isStrictViewBlockWithImage(node: unknown): node is ViewBlockWithImage {
+  return isBaseNode(node) && node.concept === 'ViewBlockWithImage';
+}
+
 /**
  * 严格判断输入为 AuthInterface 节点
  *
@@ -2571,271 +2796,573 @@ export function isEntityProperty(node: unknown): node is EntityProperty {
  * 判断输入为 EntityIndex 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，EntityIndex 节点没有继承类，此判断等价于`isStrictEntityIndex`
+ * @description 等价于`instanceof`运算，EntityIndex 节点没有继承类，此判断等价于`isStrictEntityIndex`
+ * @example
+ * ```ts
+ * if (isEntityIndex(node)) {
+ *   // 在这个花括号内，node 的类型是 EntityIndex 或者 EntityIndex 继承类型
+ * }
+ * ```
+ */
+export function isEntityIndex(node: unknown): node is EntityIndex {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'EntityIndex'
+    )
+  );
+}
+
+/**
+ * 判断输入为 MetadataType 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，MetadataType 节点没有继承类，此判断等价于`isStrictMetadataType`
+ * @example
+ * ```ts
+ * if (isMetadataType(node)) {
+ *   // 在这个花括号内，node 的类型是 MetadataType 或者 MetadataType 继承类型
+ * }
+ * ```
+ */
+export function isMetadataType(node: unknown): node is MetadataType {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'MetadataType'
+    )
+  );
+}
+
+/**
+ * 判断输入为 View 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，View 节点没有继承类，此判断等价于`isStrictView`
+ * @example
+ * ```ts
+ * if (isView(node)) {
+ *   // 在这个花括号内，node 的类型是 View 或者 View 继承类型
+ * }
+ * ```
+ */
+export function isView(node: unknown): node is View {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'View'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ViewElement 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ViewElement 节点没有继承类，此判断等价于`isStrictViewElement`
+ * @example
+ * ```ts
+ * if (isViewElement(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewElement 或者 ViewElement 继承类型
+ * }
+ * ```
+ */
+export function isViewElement(node: unknown): node is ViewElement {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ViewElement'
+    )
+  );
+}
+
+/**
+ * 判断输入为 BindAttribute 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BindAttribute 节点没有继承类，此判断等价于`isStrictBindAttribute`
+ * @example
+ * ```ts
+ * if (isBindAttribute(node)) {
+ *   // 在这个花括号内，node 的类型是 BindAttribute 或者 BindAttribute 继承类型
+ * }
+ * ```
+ */
+export function isBindAttribute(node: unknown): node is BindAttribute {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BindAttribute'
+    )
+  );
+}
+
+/**
+ * 判断输入为 BindDirective 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BindDirective 节点没有继承类，此判断等价于`isStrictBindDirective`
+ * @example
+ * ```ts
+ * if (isBindDirective(node)) {
+ *   // 在这个花括号内，node 的类型是 BindDirective 或者 BindDirective 继承类型
+ * }
+ * ```
+ */
+export function isBindDirective(node: unknown): node is BindDirective {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BindDirective'
+    )
+  );
+}
+
+/**
+ * 判断输入为 BindEvent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BindEvent 节点没有继承类，此判断等价于`isStrictBindEvent`
+ * @example
+ * ```ts
+ * if (isBindEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 BindEvent 或者 BindEvent 继承类型
+ * }
+ * ```
+ */
+export function isBindEvent(node: unknown): node is BindEvent {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BindEvent'
+    )
+  );
+}
+
+/**
+ * 判断输入为 BindStyle 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BindStyle 节点没有继承类，此判断等价于`isStrictBindStyle`
+ * @example
+ * ```ts
+ * if (isBindStyle(node)) {
+ *   // 在这个花括号内，node 的类型是 BindStyle 或者 BindStyle 继承类型
+ * }
+ * ```
+ */
+export function isBindStyle(node: unknown): node is BindStyle {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BindStyle'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ThemeVariable 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ThemeVariable 节点没有继承类，此判断等价于`isStrictThemeVariable`
+ * @example
+ * ```ts
+ * if (isThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型是 ThemeVariable 或者 ThemeVariable 继承类型
+ * }
+ * ```
+ */
+export function isThemeVariable(node: unknown): node is ThemeVariable {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ThemeVariable'
+    )
+  );
+}
+
+/**
+ * 判断输入为 BaseSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isBaseSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 BaseSetter 或者 BaseSetter 继承类型
+ * }
+ * ```
+ */
+export function isBaseSetter(node: unknown): node is types.BaseSetterNode {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BaseSetter' ||
+      node.concept === 'InputSetter' ||
+      node.concept === 'SwitchSetter' ||
+      node.concept === 'EnumSelectSetter' ||
+      node.concept === 'CapsulesSetter' ||
+      node.concept === 'NumberInputSetter' ||
+      node.concept === 'IconSetter' ||
+      node.concept === 'ImageSetter' ||
+      node.concept === 'PropertySelectSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 InputSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，InputSetter 节点没有继承类，此判断等价于`isStrictInputSetter`
+ * @example
+ * ```ts
+ * if (isInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 InputSetter 或者 InputSetter 继承类型
+ * }
+ * ```
+ */
+export function isInputSetter(node: unknown): node is InputSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'InputSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 SwitchSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SwitchSetter 节点没有继承类，此判断等价于`isStrictSwitchSetter`
+ * @example
+ * ```ts
+ * if (isSwitchSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 SwitchSetter 或者 SwitchSetter 继承类型
+ * }
+ * ```
+ */
+export function isSwitchSetter(node: unknown): node is SwitchSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'SwitchSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 SetterOption 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SetterOption 节点没有继承类，此判断等价于`isStrictSetterOption`
+ * @example
+ * ```ts
+ * if (isSetterOption(node)) {
+ *   // 在这个花括号内，node 的类型是 SetterOption 或者 SetterOption 继承类型
+ * }
+ * ```
+ */
+export function isSetterOption(node: unknown): node is SetterOption {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'SetterOption'
+    )
+  );
+}
+
+/**
+ * 判断输入为 EnumSelectSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，EnumSelectSetter 节点没有继承类，此判断等价于`isStrictEnumSelectSetter`
+ * @example
+ * ```ts
+ * if (isEnumSelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 EnumSelectSetter 或者 EnumSelectSetter 继承类型
+ * }
+ * ```
+ */
+export function isEnumSelectSetter(node: unknown): node is EnumSelectSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'EnumSelectSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 CapsulesSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，CapsulesSetter 节点没有继承类，此判断等价于`isStrictCapsulesSetter`
  * @example
  * ```ts
- * if (isEntityIndex(node)) {
- *   // 在这个花括号内，node 的类型是 EntityIndex 或者 EntityIndex 继承类型
+ * if (isCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 CapsulesSetter 或者 CapsulesSetter 继承类型
  * }
  * ```
  */
-export function isEntityIndex(node: unknown): node is EntityIndex {
+export function isCapsulesSetter(node: unknown): node is CapsulesSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'EntityIndex'
+      node.concept === 'CapsulesSetter'
     )
   );
 }
 
 /**
- * 判断输入为 MetadataType 节点实例
+ * 判断输入为 NumberInputSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，MetadataType 节点没有继承类，此判断等价于`isStrictMetadataType`
+ * @description 等价于`instanceof`运算，NumberInputSetter 节点没有继承类，此判断等价于`isStrictNumberInputSetter`
  * @example
  * ```ts
- * if (isMetadataType(node)) {
- *   // 在这个花括号内，node 的类型是 MetadataType 或者 MetadataType 继承类型
+ * if (isNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 NumberInputSetter 或者 NumberInputSetter 继承类型
  * }
  * ```
  */
-export function isMetadataType(node: unknown): node is MetadataType {
+export function isNumberInputSetter(node: unknown): node is NumberInputSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'MetadataType'
+      node.concept === 'NumberInputSetter'
     )
   );
 }
 
 /**
- * 判断输入为 View 节点实例
+ * 判断输入为 IconSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，View 节点没有继承类，此判断等价于`isStrictView`
+ * @description 等价于`instanceof`运算，IconSetter 节点没有继承类，此判断等价于`isStrictIconSetter`
  * @example
  * ```ts
- * if (isView(node)) {
- *   // 在这个花括号内，node 的类型是 View 或者 View 继承类型
+ * if (isIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 IconSetter 或者 IconSetter 继承类型
  * }
  * ```
  */
-export function isView(node: unknown): node is View {
+export function isIconSetter(node: unknown): node is IconSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'View'
+      node.concept === 'IconSetter'
     )
   );
 }
 
 /**
- * 判断输入为 ViewElement 节点实例
+ * 判断输入为 ImageSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewElement 节点没有继承类，此判断等价于`isStrictViewElement`
+ * @description 等价于`instanceof`运算，ImageSetter 节点没有继承类，此判断等价于`isStrictImageSetter`
  * @example
  * ```ts
- * if (isViewElement(node)) {
- *   // 在这个花括号内，node 的类型是 ViewElement 或者 ViewElement 继承类型
+ * if (isImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 ImageSetter 或者 ImageSetter 继承类型
  * }
  * ```
  */
-export function isViewElement(node: unknown): node is ViewElement {
+export function isImageSetter(node: unknown): node is ImageSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ViewElement'
+      node.concept === 'ImageSetter'
     )
   );
 }
 
 /**
- * 判断输入为 BindAttribute 节点实例
+ * 判断输入为 PropertySelectSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BindAttribute 节点没有继承类，此判断等价于`isStrictBindAttribute`
+ * @description 等价于`instanceof`运算，PropertySelectSetter 节点没有继承类，此判断等价于`isStrictPropertySelectSetter`
  * @example
  * ```ts
- * if (isBindAttribute(node)) {
- *   // 在这个花括号内，node 的类型是 BindAttribute 或者 BindAttribute 继承类型
+ * if (isPropertySelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 PropertySelectSetter 或者 PropertySelectSetter 继承类型
  * }
  * ```
  */
-export function isBindAttribute(node: unknown): node is BindAttribute {
+export function isPropertySelectSetter(node: unknown): node is PropertySelectSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BindAttribute'
+      node.concept === 'PropertySelectSetter'
     )
   );
 }
 
 /**
- * 判断输入为 BindDirective 节点实例
+ * 判断输入为 ViewComponentDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BindDirective 节点没有继承类，此判断等价于`isStrictBindDirective`
+ * @description 等价于`instanceof`运算，ViewComponentDeclaration 节点没有继承类，此判断等价于`isStrictViewComponentDeclaration`
  * @example
  * ```ts
- * if (isBindDirective(node)) {
- *   // 在这个花括号内，node 的类型是 BindDirective 或者 BindDirective 继承类型
+ * if (isViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
  * }
  * ```
  */
-export function isBindDirective(node: unknown): node is BindDirective {
+export function isViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BindDirective'
+      node.concept === 'ViewComponentDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 BindEvent 节点实例
+ * 判断输入为 BusinessComponent 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BindEvent 节点没有继承类，此判断等价于`isStrictBindEvent`
+ * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
  * @example
  * ```ts
- * if (isBindEvent(node)) {
- *   // 在这个花括号内，node 的类型是 BindEvent 或者 BindEvent 继承类型
+ * if (isBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
  * }
  * ```
  */
-export function isBindEvent(node: unknown): node is BindEvent {
+export function isBusinessComponent(node: unknown): node is BusinessComponent {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BindEvent'
+      node.concept === 'BusinessComponent'
     )
   );
 }
 
 /**
- * 判断输入为 BindStyle 节点实例
+ * 判断输入为 Attribute 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BindStyle 节点没有继承类，此判断等价于`isStrictBindStyle`
+ * @description 等价于`instanceof`运算，Attribute 节点没有继承类，此判断等价于`isStrictAttribute`
  * @example
  * ```ts
- * if (isBindStyle(node)) {
- *   // 在这个花括号内，node 的类型是 BindStyle 或者 BindStyle 继承类型
+ * if (isAttribute(node)) {
+ *   // 在这个花括号内，node 的类型是 Attribute 或者 Attribute 继承类型
  * }
  * ```
  */
-export function isBindStyle(node: unknown): node is BindStyle {
+export function isAttribute(node: unknown): node is Attribute {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BindStyle'
+      node.concept === 'Attribute'
     )
   );
 }
 
 /**
- * 判断输入为 ViewComponent 节点实例
+ * 判断输入为 Event 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewComponent 节点没有继承类，此判断等价于`isStrictViewComponent`
+ * @description 等价于`instanceof`运算，Event 节点没有继承类，此判断等价于`isStrictEvent`
  * @example
  * ```ts
- * if (isViewComponent(node)) {
- *   // 在这个花括号内，node 的类型是 ViewComponent 或者 ViewComponent 继承类型
+ * if (isEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 Event 或者 Event 继承类型
  * }
  * ```
  */
-export function isViewComponent(node: unknown): node is ViewComponent {
+export function isEvent(node: unknown): node is Event {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ViewComponent'
+      node.concept === 'Event'
     )
   );
 }
 
 /**
- * 判断输入为 BusinessComponent 节点实例
+ * 判断输入为 PropDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
+ * @description 等价于`instanceof`运算，PropDeclaration 节点没有继承类，此判断等价于`isStrictPropDeclaration`
  * @example
  * ```ts
- * if (isBusinessComponent(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
+ * if (isPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 PropDeclaration 或者 PropDeclaration 继承类型
  * }
  * ```
  */
-export function isBusinessComponent(node: unknown): node is BusinessComponent {
+export function isPropDeclaration(node: unknown): node is PropDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BusinessComponent'
+      node.concept === 'PropDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 Attribute 节点实例
+ * 判断输入为 EventDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Attribute 节点没有继承类，此判断等价于`isStrictAttribute`
+ * @description 等价于`instanceof`运算，EventDeclaration 节点没有继承类，此判断等价于`isStrictEventDeclaration`
  * @example
  * ```ts
- * if (isAttribute(node)) {
- *   // 在这个花括号内，node 的类型是 Attribute 或者 Attribute 继承类型
+ * if (isEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 EventDeclaration 或者 EventDeclaration 继承类型
  * }
  * ```
  */
-export function isAttribute(node: unknown): node is Attribute {
+export function isEventDeclaration(node: unknown): node is EventDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Attribute'
+      node.concept === 'EventDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 Event 节点实例
+ * 判断输入为 SlotDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Event 节点没有继承类，此判断等价于`isStrictEvent`
+ * @description 等价于`instanceof`运算，SlotDeclaration 节点没有继承类，此判断等价于`isStrictSlotDeclaration`
  * @example
  * ```ts
- * if (isEvent(node)) {
- *   // 在这个花括号内，node 的类型是 Event 或者 Event 继承类型
+ * if (isSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 SlotDeclaration 或者 SlotDeclaration 继承类型
  * }
  * ```
  */
-export function isEvent(node: unknown): node is Event {
+export function isSlotDeclaration(node: unknown): node is SlotDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Event'
+      node.concept === 'SlotDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 Slot 节点实例
+ * 判断输入为 LogicDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Slot 节点没有继承类，此判断等价于`isStrictSlot`
+ * @description 等价于`instanceof`运算，LogicDeclaration 节点没有继承类，此判断等价于`isStrictLogicDeclaration`
  * @example
  * ```ts
- * if (isSlot(node)) {
- *   // 在这个花括号内，node 的类型是 Slot 或者 Slot 继承类型
+ * if (isLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 LogicDeclaration 或者 LogicDeclaration 继承类型
  * }
  * ```
  */
-export function isSlot(node: unknown): node is Slot {
+export function isLogicDeclaration(node: unknown): node is LogicDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Slot'
+      node.concept === 'LogicDeclaration'
     )
   );
 }
@@ -4933,7 +5460,7 @@ export function isFrontendLibrary(node: unknown): node is FrontendLibrary {
  * 判断输入为 ViewBlock 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewBlock 节点没有继承类，此判断等价于`isStrictViewBlock`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isViewBlock(node)) {
@@ -4941,11 +5468,33 @@ export function isFrontendLibrary(node: unknown): node is FrontendLibrary {
  * }
  * ```
  */
-export function isViewBlock(node: unknown): node is ViewBlock {
+export function isViewBlock(node: unknown): node is types.ViewBlockNode {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ViewBlock' ||
+      node.concept === 'ViewBlockWithImage'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ViewBlockWithImage 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ViewBlockWithImage 节点没有继承类，此判断等价于`isStrictViewBlockWithImage`
+ * @example
+ * ```ts
+ * if (isViewBlockWithImage(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewBlockWithImage 或者 ViewBlockWithImage 继承类型
+ * }
+ * ```
+ */
+export function isViewBlockWithImage(node: unknown): node is ViewBlockWithImage {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ViewBlock'
+      node.concept === 'ViewBlockWithImage'
     )
   );
 }
@@ -5478,150 +6027,320 @@ export function assertStrictEntityProperty(node: unknown): asserts node is Entit
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictEntityIndex(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityIndex 类型
+ * assertStrictEntityIndex(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityIndex 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictEntityIndex(node: unknown): asserts node is EntityIndex {
+  if (!isStrictEntityIndex(node)) {
+    throw new Error(`EntityIndex 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 MetadataType 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictMetadataType(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MetadataType 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictMetadataType(node: unknown): asserts node is MetadataType {
+  if (!isStrictMetadataType(node)) {
+    throw new Error(`MetadataType 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 View 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictView(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 View 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictView(node: unknown): asserts node is View {
+  if (!isStrictView(node)) {
+    throw new Error(`View 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 ViewElement 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictViewElement(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewElement 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictViewElement(node: unknown): asserts node is ViewElement {
+  if (!isStrictViewElement(node)) {
+    throw new Error(`ViewElement 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 BindAttribute 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBindAttribute(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBindAttribute(node: unknown): asserts node is BindAttribute {
+  if (!isStrictBindAttribute(node)) {
+    throw new Error(`BindAttribute 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 BindDirective 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBindDirective(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBindDirective(node: unknown): asserts node is BindDirective {
+  if (!isStrictBindDirective(node)) {
+    throw new Error(`BindDirective 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 BindEvent 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBindEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBindEvent(node: unknown): asserts node is BindEvent {
+  if (!isStrictBindEvent(node)) {
+    throw new Error(`BindEvent 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 BindStyle 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBindStyle(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBindStyle(node: unknown): asserts node is BindStyle {
+  if (!isStrictBindStyle(node)) {
+    throw new Error(`BindStyle 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 ThemeVariable 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictThemeVariable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictThemeVariable(node: unknown): asserts node is ThemeVariable {
+  if (!isStrictThemeVariable(node)) {
+    throw new Error(`ThemeVariable 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 InputSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InputSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictInputSetter(node: unknown): asserts node is InputSetter {
+  if (!isStrictInputSetter(node)) {
+    throw new Error(`InputSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 SwitchSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSwitchSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictEntityIndex(node: unknown): asserts node is EntityIndex {
-  if (!isStrictEntityIndex(node)) {
-    throw new Error(`EntityIndex 节点严格断言失败`);
+export function assertStrictSwitchSetter(node: unknown): asserts node is SwitchSetter {
+  if (!isStrictSwitchSetter(node)) {
+    throw new Error(`SwitchSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 MetadataType 节点
+ * 严格断言为 SetterOption 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictMetadataType(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MetadataType 类型
+ * assertStrictSetterOption(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SetterOption 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictMetadataType(node: unknown): asserts node is MetadataType {
-  if (!isStrictMetadataType(node)) {
-    throw new Error(`MetadataType 节点严格断言失败`);
+export function assertStrictSetterOption(node: unknown): asserts node is SetterOption {
+  if (!isStrictSetterOption(node)) {
+    throw new Error(`SetterOption 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 View 节点
+ * 严格断言为 EnumSelectSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictView(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 View 类型
+ * assertStrictEnumSelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumSelectSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictView(node: unknown): asserts node is View {
-  if (!isStrictView(node)) {
-    throw new Error(`View 节点严格断言失败`);
+export function assertStrictEnumSelectSetter(node: unknown): asserts node is EnumSelectSetter {
+  if (!isStrictEnumSelectSetter(node)) {
+    throw new Error(`EnumSelectSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 ViewElement 节点
+ * 严格断言为 CapsulesSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictViewElement(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewElement 类型
+ * assertStrictCapsulesSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CapsulesSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictViewElement(node: unknown): asserts node is ViewElement {
-  if (!isStrictViewElement(node)) {
-    throw new Error(`ViewElement 节点严格断言失败`);
+export function assertStrictCapsulesSetter(node: unknown): asserts node is CapsulesSetter {
+  if (!isStrictCapsulesSetter(node)) {
+    throw new Error(`CapsulesSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 BindAttribute 节点
+ * 严格断言为 NumberInputSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictBindAttribute(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 类型
+ * assertStrictNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictBindAttribute(node: unknown): asserts node is BindAttribute {
-  if (!isStrictBindAttribute(node)) {
-    throw new Error(`BindAttribute 节点严格断言失败`);
+export function assertStrictNumberInputSetter(node: unknown): asserts node is NumberInputSetter {
+  if (!isStrictNumberInputSetter(node)) {
+    throw new Error(`NumberInputSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 BindDirective 节点
+ * 严格断言为 IconSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictBindDirective(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 类型
+ * assertStrictIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictBindDirective(node: unknown): asserts node is BindDirective {
-  if (!isStrictBindDirective(node)) {
-    throw new Error(`BindDirective 节点严格断言失败`);
+export function assertStrictIconSetter(node: unknown): asserts node is IconSetter {
+  if (!isStrictIconSetter(node)) {
+    throw new Error(`IconSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 BindEvent 节点
+ * 严格断言为 ImageSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictBindEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 类型
+ * assertStrictImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictBindEvent(node: unknown): asserts node is BindEvent {
-  if (!isStrictBindEvent(node)) {
-    throw new Error(`BindEvent 节点严格断言失败`);
+export function assertStrictImageSetter(node: unknown): asserts node is ImageSetter {
+  if (!isStrictImageSetter(node)) {
+    throw new Error(`ImageSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 BindStyle 节点
+ * 严格断言为 PropertySelectSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictBindStyle(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 类型
+ * assertStrictPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictBindStyle(node: unknown): asserts node is BindStyle {
-  if (!isStrictBindStyle(node)) {
-    throw new Error(`BindStyle 节点严格断言失败`);
+export function assertStrictPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter {
+  if (!isStrictPropertySelectSetter(node)) {
+    throw new Error(`PropertySelectSetter 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 ViewComponent 节点
+ * 严格断言为 ViewComponentDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 类型
+ * assertStrictViewComponentDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictViewComponent(node: unknown): asserts node is ViewComponent {
-  if (!isStrictViewComponent(node)) {
-    throw new Error(`ViewComponent 节点严格断言失败`);
+export function assertStrictViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration {
+  if (!isStrictViewComponentDeclaration(node)) {
+    throw new Error(`ViewComponentDeclaration 节点严格断言失败`);
   }
 }
 
@@ -5677,19 +6396,70 @@ export function assertStrictEvent(node: unknown): asserts node is Event {
 }
 
 /**
- * 严格断言为 Slot 节点
+ * 严格断言为 PropDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictPropDeclaration(node: unknown): asserts node is PropDeclaration {
+  if (!isStrictPropDeclaration(node)) {
+    throw new Error(`PropDeclaration 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 EventDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictEventDeclaration(node: unknown): asserts node is EventDeclaration {
+  if (!isStrictEventDeclaration(node)) {
+    throw new Error(`EventDeclaration 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 SlotDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictSlotDeclaration(node: unknown): asserts node is SlotDeclaration {
+  if (!isStrictSlotDeclaration(node)) {
+    throw new Error(`SlotDeclaration 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 LogicDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 类型
+ * assertStrictLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictSlot(node: unknown): asserts node is Slot {
-  if (!isStrictSlot(node)) {
-    throw new Error(`Slot 节点严格断言失败`);
+export function assertStrictLogicDeclaration(node: unknown): asserts node is LogicDeclaration {
+  if (!isStrictLogicDeclaration(node)) {
+    throw new Error(`LogicDeclaration 节点严格断言失败`);
   }
 }
 
@@ -7274,6 +8044,23 @@ export function assertStrictViewBlock(node: unknown): asserts node is ViewBlock
   }
 }
 
+/**
+ * 严格断言为 ViewBlockWithImage 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictViewBlockWithImage(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlockWithImage 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictViewBlockWithImage(node: unknown): asserts node is ViewBlockWithImage {
+  if (!isStrictViewBlockWithImage(node)) {
+    throw new Error(`ViewBlockWithImage 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 AuthInterface 节点
  *
@@ -7917,20 +8704,218 @@ export function assertBindStyle(node: unknown): asserts node is BindStyle {
 }
 
 /**
- * 断言为 ViewComponent 节点
+ * 断言为 ThemeVariable 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictThemeVariable`方法
+ * @example
+ * ```ts
+ * assertThemeVariable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 或者 ThemeVariable 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertThemeVariable(node: unknown): asserts node is ThemeVariable {
+  if (!isThemeVariable(node)) {
+    throw new Error(`ThemeVariable 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 BaseSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBaseSetter`方法
+ * @example
+ * ```ts
+ * assertBaseSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BaseSetter 或者 BaseSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBaseSetter(node: unknown): asserts node is types.BaseSetterNode {
+  if (!isBaseSetter(node)) {
+    throw new Error(`BaseSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 InputSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictInputSetter`方法
+ * @example
+ * ```ts
+ * assertInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InputSetter 或者 InputSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertInputSetter(node: unknown): asserts node is InputSetter {
+  if (!isInputSetter(node)) {
+    throw new Error(`InputSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 SwitchSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSwitchSetter`方法
+ * @example
+ * ```ts
+ * assertSwitchSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchSetter 或者 SwitchSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertSwitchSetter(node: unknown): asserts node is SwitchSetter {
+  if (!isSwitchSetter(node)) {
+    throw new Error(`SwitchSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 SetterOption 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSetterOption`方法
+ * @example
+ * ```ts
+ * assertSetterOption(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SetterOption 或者 SetterOption 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertSetterOption(node: unknown): asserts node is SetterOption {
+  if (!isSetterOption(node)) {
+    throw new Error(`SetterOption 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 EnumSelectSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictEnumSelectSetter`方法
+ * @example
+ * ```ts
+ * assertEnumSelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumSelectSetter 或者 EnumSelectSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertEnumSelectSetter(node: unknown): asserts node is EnumSelectSetter {
+  if (!isEnumSelectSetter(node)) {
+    throw new Error(`EnumSelectSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 CapsulesSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictCapsulesSetter`方法
+ * @example
+ * ```ts
+ * assertCapsulesSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CapsulesSetter 或者 CapsulesSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertCapsulesSetter(node: unknown): asserts node is CapsulesSetter {
+  if (!isCapsulesSetter(node)) {
+    throw new Error(`CapsulesSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 NumberInputSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictNumberInputSetter`方法
+ * @example
+ * ```ts
+ * assertNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 或者 NumberInputSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertNumberInputSetter(node: unknown): asserts node is NumberInputSetter {
+  if (!isNumberInputSetter(node)) {
+    throw new Error(`NumberInputSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 IconSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictIconSetter`方法
+ * @example
+ * ```ts
+ * assertIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 或者 IconSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertIconSetter(node: unknown): asserts node is IconSetter {
+  if (!isIconSetter(node)) {
+    throw new Error(`IconSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 ImageSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictImageSetter`方法
+ * @example
+ * ```ts
+ * assertImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 或者 ImageSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertImageSetter(node: unknown): asserts node is ImageSetter {
+  if (!isImageSetter(node)) {
+    throw new Error(`ImageSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 PropertySelectSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPropertySelectSetter`方法
+ * @example
+ * ```ts
+ * assertPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 或者 PropertySelectSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter {
+  if (!isPropertySelectSetter(node)) {
+    throw new Error(`PropertySelectSetter 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 ViewComponentDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictViewComponent`方法
+ * @description 节点没有继承类时，等价于`assertStrictViewComponentDeclaration`方法
  * @example
  * ```ts
- * assertViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 或者 ViewComponent 继承类型
+ * assertViewComponentDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertViewComponent(node: unknown): asserts node is ViewComponent {
-  if (!isViewComponent(node)) {
-    throw new Error(`ViewComponent 节点断言失败`);
+export function assertViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration {
+  if (!isViewComponentDeclaration(node)) {
+    throw new Error(`ViewComponentDeclaration 节点断言失败`);
   }
 }
 
@@ -7989,20 +8974,74 @@ export function assertEvent(node: unknown): asserts node is Event {
 }
 
 /**
- * 断言为 Slot 节点
+ * 断言为 PropDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPropDeclaration`方法
+ * @example
+ * ```ts
+ * assertPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 或者 PropDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertPropDeclaration(node: unknown): asserts node is PropDeclaration {
+  if (!isPropDeclaration(node)) {
+    throw new Error(`PropDeclaration 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 EventDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictEventDeclaration`方法
+ * @example
+ * ```ts
+ * assertEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 或者 EventDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertEventDeclaration(node: unknown): asserts node is EventDeclaration {
+  if (!isEventDeclaration(node)) {
+    throw new Error(`EventDeclaration 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 SlotDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSlotDeclaration`方法
+ * @example
+ * ```ts
+ * assertSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 或者 SlotDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertSlotDeclaration(node: unknown): asserts node is SlotDeclaration {
+  if (!isSlotDeclaration(node)) {
+    throw new Error(`SlotDeclaration 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 LogicDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictSlot`方法
+ * @description 节点没有继承类时，等价于`assertStrictLogicDeclaration`方法
  * @example
  * ```ts
- * assertSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 或者 Slot 继承类型
+ * assertLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 或者 LogicDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertSlot(node: unknown): asserts node is Slot {
-  if (!isSlot(node)) {
-    throw new Error(`Slot 节点断言失败`);
+export function assertLogicDeclaration(node: unknown): asserts node is LogicDeclaration {
+  if (!isLogicDeclaration(node)) {
+    throw new Error(`LogicDeclaration 节点断言失败`);
   }
 }
 
@@ -9746,12 +10785,30 @@ export function assertFrontendLibrary(node: unknown): asserts node is FrontendLi
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertViewBlock(node: unknown): asserts node is ViewBlock {
+export function assertViewBlock(node: unknown): asserts node is types.ViewBlockNode {
   if (!isViewBlock(node)) {
     throw new Error(`ViewBlock 节点断言失败`);
   }
 }
 
+/**
+ * 断言为 ViewBlockWithImage 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictViewBlockWithImage`方法
+ * @example
+ * ```ts
+ * assertViewBlockWithImage(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlockWithImage 或者 ViewBlockWithImage 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertViewBlockWithImage(node: unknown): asserts node is ViewBlockWithImage {
+  if (!isViewBlockWithImage(node)) {
+    throw new Error(`ViewBlockWithImage 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 AuthInterface 节点
  *