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

package/src/concepts/utils/asserts.ts

@@ -24,18 +24,31 @@ 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 { StaticString } from '../StaticString__';
 import type { Logic } from '../Logic__';
 import type { AuthLogic } from '../AuthLogic__';
-import type { BusinessLogic } from '../BusinessLogic__';
 import type { AuthLogicForCallInterface } from '../AuthLogicForCallInterface__';
 import type { OverriddenLogic } from '../OverriddenLogic__';
+import type { BusinessLogic } from '../BusinessLogic__';
 import type { AbstractInterface } from '../AbstractInterface__';
 import type { Param } from '../Param__';
 import type { ParamWithGroup } from '../ParamWithGroup__';
@@ -47,8 +60,8 @@ import type { Constant } from '../Constant__';
 import type { LogicItem } from '../LogicItem__';
 import type { Function } from '../Function__';
 import type { AnonymousFunction } from '../AnonymousFunction__';
-import type { Interface } from '../Interface__';
 import type { ImportedInterface } from '../ImportedInterface__';
+import type { Interface } from '../Interface__';
 import type { InterfaceParam } from '../InterfaceParam__';
 import type { Transactional } from '../Transactional__';
 import type { DefaultValue } from '../DefaultValue__';
@@ -80,6 +93,7 @@ import type { NullLiteral } from '../NullLiteral__';
 import type { BooleanLiteral } from '../BooleanLiteral__';
 import type { StringLiteral } from '../StringLiteral__';
 import type { StringInterpolation } from '../StringInterpolation__';
+import type { StaticString } from '../StaticString__';
 import type { NumericLiteral } from '../NumericLiteral__';
 import type { BinaryExpression } from '../BinaryExpression__';
 import type { MatchCase } from '../MatchCase__';
@@ -91,6 +105,7 @@ import type { New } from '../New__';
 import type { NewComposite } from '../NewComposite__';
 import type { NewList } from '../NewList__';
 import type { NewMap } from '../NewMap__';
+import type { Paginate } from '../Paginate__';
 import type { CallQueryComponent } from '../CallQueryComponent__';
 import type { QueryFromExpression } from '../QueryFromExpression__';
 import type { QueryJoinExpression } from '../QueryJoinExpression__';
@@ -105,12 +120,12 @@ import type { OqlQueryComponent } from '../OqlQueryComponent__';
 import type { Process } from '../Process__';
 import type { ProcessElement } from '../ProcessElement__';
 import type { ProcessComponent } from '../ProcessComponent__';
-import type { ProcessOutcome } from '../ProcessOutcome__';
-import type { Assignee } from '../Assignee__';
-import type { ProcessOutcomes } from '../ProcessOutcomes__';
 import type { MultiApprovalPolicy } from '../MultiApprovalPolicy__';
 import type { SequentialPolicy } from '../SequentialPolicy__';
 import type { CountersignPolicy } from '../CountersignPolicy__';
+import type { ProcessOutcome } from '../ProcessOutcome__';
+import type { Assignee } from '../Assignee__';
+import type { ProcessOutcomes } from '../ProcessOutcomes__';
 import type { Role } from '../Role__';
 import type { Configuration } from '../Configuration__';
 import type { ConfigGroup } from '../ConfigGroup__';
@@ -125,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__';
@@ -135,7 +151,7 @@ import type { MsgTriggerLauncher } from '../MsgTriggerLauncher__';
 import type { Connector } from '../Connector__';
 import type { CallConnector } from '../CallConnector__';
 import type { Connection } from '../Connection__';
-import type * as Type from './types';
+import type * as types from './types';
 import type { BaseNode } from '../../common';
 import type { FileNode } from '../../utils';
 
@@ -564,18 +580,168 @@ export function isStrictBindStyle(node: unknown): node is BindStyle {
 }
 
 /**
- * 严格判断输入为 ViewComponent 节点
+ * 严格判断输入为 ThemeVariable 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型为 ThemeVariable
+ * }
+ * ```
+ */
+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 (isStrictViewComponent(node)) {
- *   // 在这个花括号内，node 的类型为 ViewComponent
+ * if (isStrictViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 ViewComponentDeclaration
  * }
  * ```
  */
-export function isStrictViewComponent(node: unknown): node is ViewComponent {
-  return isBaseNode(node) && node.concept === 'ViewComponent';
+export function isStrictViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration {
+  return isBaseNode(node) && node.concept === 'ViewComponentDeclaration';
 }
 
 /**
@@ -624,93 +790,108 @@ 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';
 }
 
 /**
- * 严格判断输入为 Theme 节点
+ * 严格判断输入为 EventDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictTheme(node)) {
- *   // 在这个花括号内，node 的类型为 Theme
+ * if (isStrictEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 EventDeclaration
  * }
  * ```
  */
-export function isStrictTheme(node: unknown): node is Theme {
-  return isBaseNode(node) && node.concept === 'Theme';
+export function isStrictEventDeclaration(node: unknown): node is EventDeclaration {
+  return isBaseNode(node) && node.concept === 'EventDeclaration';
 }
 
 /**
- * 严格判断输入为 StaticString 节点
+ * 严格判断输入为 SlotDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictStaticString(node)) {
- *   // 在这个花括号内，node 的类型为 StaticString
+ * if (isStrictSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 SlotDeclaration
  * }
  * ```
  */
-export function isStrictStaticString(node: unknown): node is StaticString {
-  return isBaseNode(node) && node.concept === 'StaticString';
+export function isStrictSlotDeclaration(node: unknown): node is SlotDeclaration {
+  return isBaseNode(node) && node.concept === 'SlotDeclaration';
 }
 
 /**
- * 严格判断输入为 Logic 节点
+ * 严格判断输入为 LogicDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictLogic(node)) {
- *   // 在这个花括号内，node 的类型为 Logic
+ * if (isStrictLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 LogicDeclaration
  * }
  * ```
  */
-export function isStrictLogic(node: unknown): node is Logic {
-  return isBaseNode(node) && node.concept === 'Logic';
+export function isStrictLogicDeclaration(node: unknown): node is LogicDeclaration {
+  return isBaseNode(node) && node.concept === 'LogicDeclaration';
 }
 
 /**
- * 严格判断输入为 AuthLogic 节点
+ * 严格判断输入为 Theme 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictAuthLogic(node)) {
- *   // 在这个花括号内，node 的类型为 AuthLogic
+ * if (isStrictTheme(node)) {
+ *   // 在这个花括号内，node 的类型为 Theme
  * }
  * ```
  */
-export function isStrictAuthLogic(node: unknown): node is AuthLogic {
-  return isBaseNode(node) && node.concept === 'AuthLogic';
+export function isStrictTheme(node: unknown): node is Theme {
+  return isBaseNode(node) && node.concept === 'Theme';
 }
 
 /**
- * 严格判断输入为 BusinessLogic 节点
+ * 严格判断输入为 Logic 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * if (isStrictLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 Logic
  * }
  * ```
  */
-export function isStrictBusinessLogic(node: unknown): node is BusinessLogic {
-  return isBaseNode(node) && node.concept === 'BusinessLogic';
+export function isStrictLogic(node: unknown): node is Logic {
+  return isBaseNode(node) && node.concept === 'Logic';
+}
+
+/**
+ * 严格判断输入为 AuthLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAuthLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 AuthLogic
+ * }
+ * ```
+ */
+export function isStrictAuthLogic(node: unknown): node is AuthLogic {
+  return isBaseNode(node) && node.concept === 'AuthLogic';
 }
 
 /**
@@ -743,6 +924,21 @@ export function isStrictOverriddenLogic(node: unknown): node is OverriddenLogic
   return isBaseNode(node) && node.concept === 'OverriddenLogic';
 }
 
+/**
+ * 严格判断输入为 BusinessLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * }
+ * ```
+ */
+export function isStrictBusinessLogic(node: unknown): node is BusinessLogic {
+  return isBaseNode(node) && node.concept === 'BusinessLogic';
+}
+
 /**
  * 严格判断输入为 Param 节点
  *
@@ -1358,6 +1554,21 @@ export function isStrictStringInterpolation(node: unknown): node is StringInterp
   return isBaseNode(node) && node.concept === 'StringInterpolation';
 }
 
+/**
+ * 严格判断输入为 StaticString 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictStaticString(node)) {
+ *   // 在这个花括号内，node 的类型为 StaticString
+ * }
+ * ```
+ */
+export function isStrictStaticString(node: unknown): node is StaticString {
+  return isBaseNode(node) && node.concept === 'StaticString';
+}
+
 /**
  * 严格判断输入为 NumericLiteral 节点
  *
@@ -1523,6 +1734,21 @@ export function isStrictNewMap(node: unknown): node is NewMap {
   return isBaseNode(node) && node.concept === 'NewMap';
 }
 
+/**
+ * 严格判断输入为 Paginate 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictPaginate(node)) {
+ *   // 在这个花括号内，node 的类型为 Paginate
+ * }
+ * ```
+ */
+export function isStrictPaginate(node: unknown): node is Paginate {
+  return isBaseNode(node) && node.concept === 'Paginate';
+}
+
 /**
  * 严格判断输入为 CallQueryComponent 节点
  *
@@ -1733,6 +1959,36 @@ export function isStrictProcessComponent(node: unknown): node is ProcessComponen
   return isBaseNode(node) && node.concept === 'ProcessComponent';
 }
 
+/**
+ * 严格判断输入为 SequentialPolicy 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSequentialPolicy(node)) {
+ *   // 在这个花括号内，node 的类型为 SequentialPolicy
+ * }
+ * ```
+ */
+export function isStrictSequentialPolicy(node: unknown): node is SequentialPolicy {
+  return isBaseNode(node) && node.concept === 'SequentialPolicy';
+}
+
+/**
+ * 严格判断输入为 CountersignPolicy 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictCountersignPolicy(node)) {
+ *   // 在这个花括号内，node 的类型为 CountersignPolicy
+ * }
+ * ```
+ */
+export function isStrictCountersignPolicy(node: unknown): node is CountersignPolicy {
+  return isBaseNode(node) && node.concept === 'CountersignPolicy';
+}
+
 /**
  * 严格判断输入为 ProcessOutcome 节点
  *
@@ -1779,88 +2035,43 @@ export function isStrictProcessOutcomes(node: unknown): node is ProcessOutcomes
 }
 
 /**
- * 严格判断输入为 MultiApprovalPolicy 节点
+ * 严格判断输入为 Role 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictMultiApprovalPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 MultiApprovalPolicy
+ * if (isStrictRole(node)) {
+ *   // 在这个花括号内，node 的类型为 Role
  * }
  * ```
  */
-export function isStrictMultiApprovalPolicy(node: unknown): node is MultiApprovalPolicy {
-  return isBaseNode(node) && node.concept === 'MultiApprovalPolicy';
+export function isStrictRole(node: unknown): node is Role {
+  return isBaseNode(node) && node.concept === 'Role';
 }
 
 /**
- * 严格判断输入为 SequentialPolicy 节点
+ * 严格判断输入为 Configuration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictSequentialPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 SequentialPolicy
+ * if (isStrictConfiguration(node)) {
+ *   // 在这个花括号内，node 的类型为 Configuration
  * }
  * ```
  */
-export function isStrictSequentialPolicy(node: unknown): node is SequentialPolicy {
-  return isBaseNode(node) && node.concept === 'SequentialPolicy';
+export function isStrictConfiguration(node: unknown): node is Configuration {
+  return isBaseNode(node) && node.concept === 'Configuration';
 }
 
 /**
- * 严格判断输入为 CountersignPolicy 节点
+ * 严格判断输入为 ConfigGroup 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictCountersignPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 CountersignPolicy
- * }
- * ```
- */
-export function isStrictCountersignPolicy(node: unknown): node is CountersignPolicy {
-  return isBaseNode(node) && node.concept === 'CountersignPolicy';
-}
-
-/**
- * 严格判断输入为 Role 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictRole(node)) {
- *   // 在这个花括号内，node 的类型为 Role
- * }
- * ```
- */
-export function isStrictRole(node: unknown): node is Role {
-  return isBaseNode(node) && node.concept === 'Role';
-}
-
-/**
- * 严格判断输入为 Configuration 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictConfiguration(node)) {
- *   // 在这个花括号内，node 的类型为 Configuration
- * }
- * ```
- */
-export function isStrictConfiguration(node: unknown): node is Configuration {
-  return isBaseNode(node) && node.concept === 'Configuration';
-}
-
-/**
- * 严格判断输入为 ConfigGroup 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictConfigGroup(node)) {
- *   // 在这个花括号内，node 的类型为 ConfigGroup
+ * if (isStrictConfigGroup(node)) {
+ *   // 在这个花括号内，node 的类型为 ConfigGroup
  * }
  * ```
  */
@@ -2033,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 节点
  *
@@ -2220,7 +2446,7 @@ export function isApp(node: unknown): node is App {
  * }
  * ```
  */
-export function isModule(node: unknown): node is Type.ModuleNode {
+export function isModule(node: unknown): node is types.ModuleNode {
   return (
     isBaseNode(node) &&
     (
@@ -2735,22 +2961,261 @@ export function isBindStyle(node: unknown): node is BindStyle {
 }
 
 /**
- * 判断输入为 ViewComponent 节点实例
+ * 判断输入为 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 (isCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 CapsulesSetter 或者 CapsulesSetter 继承类型
+ * }
+ * ```
+ */
+export function isCapsulesSetter(node: unknown): node is CapsulesSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'CapsulesSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 NumberInputSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，NumberInputSetter 节点没有继承类，此判断等价于`isStrictNumberInputSetter`
+ * @example
+ * ```ts
+ * if (isNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 NumberInputSetter 或者 NumberInputSetter 继承类型
+ * }
+ * ```
+ */
+export function isNumberInputSetter(node: unknown): node is NumberInputSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'NumberInputSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 IconSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，IconSetter 节点没有继承类，此判断等价于`isStrictIconSetter`
+ * @example
+ * ```ts
+ * if (isIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 IconSetter 或者 IconSetter 继承类型
+ * }
+ * ```
+ */
+export function isIconSetter(node: unknown): node is IconSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'IconSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ImageSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ImageSetter 节点没有继承类，此判断等价于`isStrictImageSetter`
+ * @example
+ * ```ts
+ * if (isImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 ImageSetter 或者 ImageSetter 继承类型
+ * }
+ * ```
+ */
+export function isImageSetter(node: unknown): node is ImageSetter {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ImageSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 PropertySelectSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewComponent 节点没有继承类，此判断等价于`isStrictViewComponent`
+ * @description 等价于`instanceof`运算，PropertySelectSetter 节点没有继承类，此判断等价于`isStrictPropertySelectSetter`
  * @example
  * ```ts
- * if (isViewComponent(node)) {
- *   // 在这个花括号内，node 的类型是 ViewComponent 或者 ViewComponent 继承类型
+ * if (isPropertySelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 PropertySelectSetter 或者 PropertySelectSetter 继承类型
  * }
  * ```
  */
-export function isViewComponent(node: unknown): node is ViewComponent {
+export function isPropertySelectSetter(node: unknown): node is PropertySelectSetter {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ViewComponent'
+      node.concept === 'PropertySelectSetter'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ViewComponentDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ViewComponentDeclaration 节点没有继承类，此判断等价于`isStrictViewComponentDeclaration`
+ * @example
+ * ```ts
+ * if (isViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
+ * }
+ * ```
+ */
+export function isViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ViewComponentDeclaration'
     )
   );
 }
@@ -2819,131 +3284,152 @@ export function isEvent(node: unknown): node is Event {
 }
 
 /**
- * 判断输入为 Slot 节点实例
+ * 判断输入为 PropDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Slot 节点没有继承类，此判断等价于`isStrictSlot`
+ * @description 等价于`instanceof`运算，PropDeclaration 节点没有继承类，此判断等价于`isStrictPropDeclaration`
  * @example
  * ```ts
- * if (isSlot(node)) {
- *   // 在这个花括号内，node 的类型是 Slot 或者 Slot 继承类型
+ * if (isPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 PropDeclaration 或者 PropDeclaration 继承类型
  * }
  * ```
  */
-export function isSlot(node: unknown): node is Slot {
+export function isPropDeclaration(node: unknown): node is PropDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Slot'
+      node.concept === 'PropDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 Theme 节点实例
+ * 判断输入为 EventDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Theme 节点没有继承类，此判断等价于`isStrictTheme`
+ * @description 等价于`instanceof`运算，EventDeclaration 节点没有继承类，此判断等价于`isStrictEventDeclaration`
  * @example
  * ```ts
- * if (isTheme(node)) {
- *   // 在这个花括号内，node 的类型是 Theme 或者 Theme 继承类型
+ * if (isEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 EventDeclaration 或者 EventDeclaration 继承类型
  * }
  * ```
  */
-export function isTheme(node: unknown): node is Theme {
+export function isEventDeclaration(node: unknown): node is EventDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Theme'
+      node.concept === 'EventDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 StaticString 节点实例
+ * 判断输入为 SlotDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，StaticString 节点没有继承类，此判断等价于`isStrictStaticString`
+ * @description 等价于`instanceof`运算，SlotDeclaration 节点没有继承类，此判断等价于`isStrictSlotDeclaration`
  * @example
  * ```ts
- * if (isStaticString(node)) {
- *   // 在这个花括号内，node 的类型是 StaticString 或者 StaticString 继承类型
+ * if (isSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 SlotDeclaration 或者 SlotDeclaration 继承类型
  * }
  * ```
  */
-export function isStaticString(node: unknown): node is StaticString {
+export function isSlotDeclaration(node: unknown): node is SlotDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'StaticString'
+      node.concept === 'SlotDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 Logic 节点实例
+ * 判断输入为 LogicDeclaration 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算
+ * @description 等价于`instanceof`运算，LogicDeclaration 节点没有继承类，此判断等价于`isStrictLogicDeclaration`
  * @example
  * ```ts
- * if (isLogic(node)) {
- *   // 在这个花括号内，node 的类型是 Logic 或者 Logic 继承类型
+ * if (isLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 LogicDeclaration 或者 LogicDeclaration 继承类型
  * }
  * ```
  */
-export function isLogic(node: unknown): node is Type.LogicNode {
+export function isLogicDeclaration(node: unknown): node is LogicDeclaration {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Logic' ||
-      node.concept === 'AuthLogic' ||
-      node.concept === 'BusinessLogic' ||
-      node.concept === 'AuthLogicForCallInterface'
+      node.concept === 'LogicDeclaration'
     )
   );
 }
 
 /**
- * 判断输入为 AuthLogic 节点实例
+ * 判断输入为 Theme 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Theme 节点没有继承类，此判断等价于`isStrictTheme`
+ * @example
+ * ```ts
+ * if (isTheme(node)) {
+ *   // 在这个花括号内，node 的类型是 Theme 或者 Theme 继承类型
+ * }
+ * ```
+ */
+export function isTheme(node: unknown): node is Theme {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'Theme'
+    )
+  );
+}
+
+/**
+ * 判断输入为 Logic 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
  * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isAuthLogic(node)) {
- *   // 在这个花括号内，node 的类型是 AuthLogic 或者 AuthLogic 继承类型
+ * if (isLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 Logic 或者 Logic 继承类型
  * }
  * ```
  */
-export function isAuthLogic(node: unknown): node is Type.AuthLogicNode {
+export function isLogic(node: unknown): node is types.LogicNode {
   return (
     isBaseNode(node) &&
     (
+      node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
-      node.concept === 'AuthLogicForCallInterface'
+      node.concept === 'AuthLogicForCallInterface' ||
+      node.concept === 'BusinessLogic'
     )
   );
 }
 
 /**
- * 判断输入为 BusinessLogic 节点实例
+ * 判断输入为 AuthLogic 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * if (isAuthLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 AuthLogic 或者 AuthLogic 继承类型
  * }
  * ```
  */
-export function isBusinessLogic(node: unknown): node is BusinessLogic {
+export function isAuthLogic(node: unknown): node is types.AuthLogicNode {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'BusinessLogic'
+      node.concept === 'AuthLogic' ||
+      node.concept === 'AuthLogicForCallInterface'
     )
   );
 }
@@ -2990,6 +3476,27 @@ export function isOverriddenLogic(node: unknown): node is OverriddenLogic {
   );
 }
 
+/**
+ * 判断输入为 BusinessLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @example
+ * ```ts
+ * if (isBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * }
+ * ```
+ */
+export function isBusinessLogic(node: unknown): node is BusinessLogic {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'BusinessLogic'
+    )
+  );
+}
+
 /**
  * 判断输入为 AbstractInterface 节点实例
  *
@@ -3002,7 +3509,7 @@ export function isOverriddenLogic(node: unknown): node is OverriddenLogic {
  * }
  * ```
  */
-export function isAbstractInterface(node: unknown): node is Type.AbstractInterfaceNode {
+export function isAbstractInterface(node: unknown): node is types.AbstractInterfaceNode {
   return (
     isBaseNode(node) &&
     (
@@ -3026,7 +3533,7 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * }
  * ```
  */
-export function isParam(node: unknown): node is Type.ParamNode {
+export function isParam(node: unknown): node is types.ParamNode {
   return (
     isBaseNode(node) &&
     (
@@ -3090,7 +3597,7 @@ export function isReturn(node: unknown): node is Return {
  * }
  * ```
  */
-export function isVariable(node: unknown): node is Type.VariableNode {
+export function isVariable(node: unknown): node is types.VariableNode {
   return (
     isBaseNode(node) &&
     (
@@ -3175,7 +3682,7 @@ export function isConstant(node: unknown): node is Constant {
  * }
  * ```
  */
-export function isLogicItem(node: unknown): node is Type.LogicItemNode {
+export function isLogicItem(node: unknown): node is types.LogicItemNode {
   return (
     isBaseNode(node) &&
     (
@@ -3193,9 +3700,11 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'BatchAssignment' ||
       node.concept === 'Comment' ||
       node.concept === 'CallLogic' ||
+      node.concept === 'CallConnector' ||
       node.concept === 'CallEvent' ||
       node.concept === 'CallFunction' ||
       node.concept === 'CallInterface' ||
+      node.concept === 'CallAuthInterface' ||
       node.concept === 'Destination' ||
       node.concept === 'ExternalDestination' ||
       node.concept === 'ValidationRule' ||
@@ -3220,6 +3729,7 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'NewComposite' ||
       node.concept === 'NewList' ||
       node.concept === 'NewMap' ||
+      node.concept === 'Paginate' ||
       node.concept === 'CallQueryComponent' ||
       node.concept === 'QueryFromExpression' ||
       node.concept === 'QueryJoinExpression' ||
@@ -3233,9 +3743,7 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'OqlQueryComponent' ||
       node.concept === 'ProcessOutcome' ||
       node.concept === 'Assignee' ||
-      node.concept === 'ProcessOutcomes' ||
-      node.concept === 'CallAuthInterface' ||
-      node.concept === 'CallConnector'
+      node.concept === 'ProcessOutcomes'
     )
   );
 }
@@ -3283,21 +3791,22 @@ export function isAnonymousFunction(node: unknown): node is AnonymousFunction {
 }
 
 /**
- * 判断输入为 Interface 节点实例
+ * 判断输入为 ImportedInterface 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
  * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isInterface(node)) {
- *   // 在这个花括号内，node 的类型是 Interface 或者 Interface 继承类型
+ * if (isImportedInterface(node)) {
+ *   // 在这个花括号内，node 的类型是 ImportedInterface 或者 ImportedInterface 继承类型
  * }
  * ```
  */
-export function isInterface(node: unknown): node is Type.InterfaceNode {
+export function isImportedInterface(node: unknown): node is types.ImportedInterfaceNode {
   return (
     isBaseNode(node) &&
     (
+      node.concept === 'ImportedInterface' ||
       node.concept === 'Interface' ||
       node.concept === 'AuthInterface'
     )
@@ -3305,22 +3814,21 @@ export function isInterface(node: unknown): node is Type.InterfaceNode {
 }
 
 /**
- * 判断输入为 ImportedInterface 节点实例
+ * 判断输入为 Interface 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
  * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isImportedInterface(node)) {
- *   // 在这个花括号内，node 的类型是 ImportedInterface 或者 ImportedInterface 继承类型
+ * if (isInterface(node)) {
+ *   // 在这个花括号内，node 的类型是 Interface 或者 Interface 继承类型
  * }
  * ```
  */
-export function isImportedInterface(node: unknown): node is Type.ImportedInterfaceNode {
+export function isInterface(node: unknown): node is types.InterfaceNode {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ImportedInterface' ||
       node.concept === 'Interface' ||
       node.concept === 'AuthInterface'
     )
@@ -3633,7 +4141,7 @@ export function isComment(node: unknown): node is Comment {
  * }
  * ```
  */
-export function isCallLogic(node: unknown): node is Type.CallLogicNode {
+export function isCallLogic(node: unknown): node is types.CallLogicNode {
   return (
     isBaseNode(node) &&
     (
@@ -3697,7 +4205,7 @@ export function isCallFunction(node: unknown): node is CallFunction {
  * }
  * ```
  */
-export function isCallInterface(node: unknown): node is Type.CallInterfaceNode {
+export function isCallInterface(node: unknown): node is types.CallInterfaceNode {
   return (
     isBaseNode(node) &&
     (
@@ -3980,6 +4488,27 @@ export function isStringInterpolation(node: unknown): node is StringInterpolatio
   );
 }
 
+/**
+ * 判断输入为 StaticString 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，StaticString 节点没有继承类，此判断等价于`isStrictStaticString`
+ * @example
+ * ```ts
+ * if (isStaticString(node)) {
+ *   // 在这个花括号内，node 的类型是 StaticString 或者 StaticString 继承类型
+ * }
+ * ```
+ */
+export function isStaticString(node: unknown): node is StaticString {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'StaticString'
+    )
+  );
+}
+
 /**
  * 判断输入为 NumericLiteral 节点实例
  *
@@ -4211,6 +4740,27 @@ export function isNewMap(node: unknown): node is NewMap {
   );
 }
 
+/**
+ * 判断输入为 Paginate 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Paginate 节点没有继承类，此判断等价于`isStrictPaginate`
+ * @example
+ * ```ts
+ * if (isPaginate(node)) {
+ *   // 在这个花括号内，node 的类型是 Paginate 或者 Paginate 继承类型
+ * }
+ * ```
+ */
+export function isPaginate(node: unknown): node is Paginate {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'Paginate'
+    )
+  );
+}
+
 /**
  * 判断输入为 CallQueryComponent 节点实例
  *
@@ -4506,129 +5056,129 @@ export function isProcessComponent(node: unknown): node is ProcessComponent {
 }
 
 /**
- * 判断输入为 ProcessOutcome 节点实例
+ * 判断输入为 MultiApprovalPolicy 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ProcessOutcome 节点没有继承类，此判断等价于`isStrictProcessOutcome`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isProcessOutcome(node)) {
- *   // 在这个花括号内，node 的类型是 ProcessOutcome 或者 ProcessOutcome 继承类型
+ * if (isMultiApprovalPolicy(node)) {
+ *   // 在这个花括号内，node 的类型是 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
  * }
  * ```
  */
-export function isProcessOutcome(node: unknown): node is ProcessOutcome {
+export function isMultiApprovalPolicy(node: unknown): node is types.MultiApprovalPolicyNode {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ProcessOutcome'
+      node.concept === 'MultiApprovalPolicy' ||
+      node.concept === 'SequentialPolicy' ||
+      node.concept === 'CountersignPolicy'
     )
   );
 }
 
 /**
- * 判断输入为 Assignee 节点实例
+ * 判断输入为 SequentialPolicy 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Assignee 节点没有继承类，此判断等价于`isStrictAssignee`
+ * @description 等价于`instanceof`运算，SequentialPolicy 节点没有继承类，此判断等价于`isStrictSequentialPolicy`
  * @example
  * ```ts
- * if (isAssignee(node)) {
- *   // 在这个花括号内，node 的类型是 Assignee 或者 Assignee 继承类型
+ * if (isSequentialPolicy(node)) {
+ *   // 在这个花括号内，node 的类型是 SequentialPolicy 或者 SequentialPolicy 继承类型
  * }
  * ```
  */
-export function isAssignee(node: unknown): node is Assignee {
+export function isSequentialPolicy(node: unknown): node is SequentialPolicy {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Assignee'
+      node.concept === 'SequentialPolicy'
     )
   );
 }
 
 /**
- * 判断输入为 ProcessOutcomes 节点实例
+ * 判断输入为 CountersignPolicy 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ProcessOutcomes 节点没有继承类，此判断等价于`isStrictProcessOutcomes`
+ * @description 等价于`instanceof`运算，CountersignPolicy 节点没有继承类，此判断等价于`isStrictCountersignPolicy`
  * @example
  * ```ts
- * if (isProcessOutcomes(node)) {
- *   // 在这个花括号内，node 的类型是 ProcessOutcomes 或者 ProcessOutcomes 继承类型
+ * if (isCountersignPolicy(node)) {
+ *   // 在这个花括号内，node 的类型是 CountersignPolicy 或者 CountersignPolicy 继承类型
  * }
  * ```
  */
-export function isProcessOutcomes(node: unknown): node is ProcessOutcomes {
+export function isCountersignPolicy(node: unknown): node is CountersignPolicy {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'ProcessOutcomes'
+      node.concept === 'CountersignPolicy'
     )
   );
 }
 
 /**
- * 判断输入为 MultiApprovalPolicy 节点实例
+ * 判断输入为 ProcessOutcome 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算
+ * @description 等价于`instanceof`运算，ProcessOutcome 节点没有继承类，此判断等价于`isStrictProcessOutcome`
  * @example
  * ```ts
- * if (isMultiApprovalPolicy(node)) {
- *   // 在这个花括号内，node 的类型是 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
+ * if (isProcessOutcome(node)) {
+ *   // 在这个花括号内，node 的类型是 ProcessOutcome 或者 ProcessOutcome 继承类型
  * }
  * ```
  */
-export function isMultiApprovalPolicy(node: unknown): node is Type.MultiApprovalPolicyNode {
+export function isProcessOutcome(node: unknown): node is ProcessOutcome {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'MultiApprovalPolicy' ||
-      node.concept === 'SequentialPolicy' ||
-      node.concept === 'CountersignPolicy'
+      node.concept === 'ProcessOutcome'
     )
   );
 }
 
 /**
- * 判断输入为 SequentialPolicy 节点实例
+ * 判断输入为 Assignee 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，SequentialPolicy 节点没有继承类，此判断等价于`isStrictSequentialPolicy`
+ * @description 等价于`instanceof`运算，Assignee 节点没有继承类，此判断等价于`isStrictAssignee`
  * @example
  * ```ts
- * if (isSequentialPolicy(node)) {
- *   // 在这个花括号内，node 的类型是 SequentialPolicy 或者 SequentialPolicy 继承类型
+ * if (isAssignee(node)) {
+ *   // 在这个花括号内，node 的类型是 Assignee 或者 Assignee 继承类型
  * }
  * ```
  */
-export function isSequentialPolicy(node: unknown): node is SequentialPolicy {
+export function isAssignee(node: unknown): node is Assignee {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'SequentialPolicy'
+      node.concept === 'Assignee'
     )
   );
 }
 
 /**
- * 判断输入为 CountersignPolicy 节点实例
+ * 判断输入为 ProcessOutcomes 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，CountersignPolicy 节点没有继承类，此判断等价于`isStrictCountersignPolicy`
+ * @description 等价于`instanceof`运算，ProcessOutcomes 节点没有继承类，此判断等价于`isStrictProcessOutcomes`
  * @example
  * ```ts
- * if (isCountersignPolicy(node)) {
- *   // 在这个花括号内，node 的类型是 CountersignPolicy 或者 CountersignPolicy 继承类型
+ * if (isProcessOutcomes(node)) {
+ *   // 在这个花括号内，node 的类型是 ProcessOutcomes 或者 ProcessOutcomes 继承类型
  * }
  * ```
  */
-export function isCountersignPolicy(node: unknown): node is CountersignPolicy {
+export function isProcessOutcomes(node: unknown): node is ProcessOutcomes {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'CountersignPolicy'
+      node.concept === 'ProcessOutcomes'
     )
   );
 }
@@ -4910,7 +5460,7 @@ export function isFrontendLibrary(node: unknown): node is FrontendLibrary {
  * 判断输入为 ViewBlock 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewBlock 节点没有继承类，此判断等价于`isStrictViewBlock`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isViewBlock(node)) {
@@ -4918,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'
     )
   );
 }
@@ -4981,7 +5553,7 @@ export function isCallAuthInterface(node: unknown): node is CallAuthInterface {
  * }
  * ```
  */
-export function isTriggerEvent(node: unknown): node is Type.TriggerEventNode {
+export function isTriggerEvent(node: unknown): node is types.TriggerEventNode {
   return (
     isBaseNode(node) &&
     (
@@ -5045,7 +5617,7 @@ export function isConnectorTrigger(node: unknown): node is ConnectorTrigger {
  * }
  * ```
  */
-export function isTriggerLauncher(node: unknown): node is Type.TriggerLauncherNode {
+export function isTriggerLauncher(node: unknown): node is types.TriggerLauncherNode {
   return (
     isBaseNode(node) &&
     (
@@ -5586,19 +6158,189 @@ export function assertStrictBindStyle(node: unknown): asserts node is BindStyle
 }
 
 /**
- * 严格断言为 ViewComponent 节点
+ * 严格断言为 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 assertStrictSwitchSetter(node: unknown): asserts node is SwitchSetter {
+  if (!isStrictSwitchSetter(node)) {
+    throw new Error(`SwitchSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 SetterOption 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSetterOption(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SetterOption 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictSetterOption(node: unknown): asserts node is SetterOption {
+  if (!isStrictSetterOption(node)) {
+    throw new Error(`SetterOption 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 EnumSelectSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictEnumSelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumSelectSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictEnumSelectSetter(node: unknown): asserts node is EnumSelectSetter {
+  if (!isStrictEnumSelectSetter(node)) {
+    throw new Error(`EnumSelectSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 CapsulesSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictCapsulesSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CapsulesSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictCapsulesSetter(node: unknown): asserts node is CapsulesSetter {
+  if (!isStrictCapsulesSetter(node)) {
+    throw new Error(`CapsulesSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 NumberInputSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictNumberInputSetter(node: unknown): asserts node is NumberInputSetter {
+  if (!isStrictNumberInputSetter(node)) {
+    throw new Error(`NumberInputSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 IconSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictIconSetter(node: unknown): asserts node is IconSetter {
+  if (!isStrictIconSetter(node)) {
+    throw new Error(`IconSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 ImageSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictImageSetter(node: unknown): asserts node is ImageSetter {
+  if (!isStrictImageSetter(node)) {
+    throw new Error(`ImageSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 PropertySelectSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter {
+  if (!isStrictPropertySelectSetter(node)) {
+    throw new Error(`PropertySelectSetter 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 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 节点严格断言失败`);
   }
 }
 
@@ -5654,53 +6396,87 @@ export function assertStrictEvent(node: unknown): asserts node is Event {
 }
 
 /**
- * 严格断言为 Slot 节点
+ * 严格断言为 PropDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 类型
+ * assertStrictPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictSlot(node: unknown): asserts node is Slot {
-  if (!isStrictSlot(node)) {
-    throw new Error(`Slot 节点严格断言失败`);
+export function assertStrictPropDeclaration(node: unknown): asserts node is PropDeclaration {
+  if (!isStrictPropDeclaration(node)) {
+    throw new Error(`PropDeclaration 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 Theme 节点
+ * 严格断言为 EventDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictTheme(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 类型
+ * assertStrictEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictTheme(node: unknown): asserts node is Theme {
-  if (!isStrictTheme(node)) {
-    throw new Error(`Theme 节点严格断言失败`);
+export function assertStrictEventDeclaration(node: unknown): asserts node is EventDeclaration {
+  if (!isStrictEventDeclaration(node)) {
+    throw new Error(`EventDeclaration 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 StaticString 节点
+ * 严格断言为 SlotDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictStaticString(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 类型
+ * assertStrictSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictStaticString(node: unknown): asserts node is StaticString {
-  if (!isStrictStaticString(node)) {
-    throw new Error(`StaticString 节点严格断言失败`);
+export function assertStrictSlotDeclaration(node: unknown): asserts node is SlotDeclaration {
+  if (!isStrictSlotDeclaration(node)) {
+    throw new Error(`SlotDeclaration 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 LogicDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictLogicDeclaration(node: unknown): asserts node is LogicDeclaration {
+  if (!isStrictLogicDeclaration(node)) {
+    throw new Error(`LogicDeclaration 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 Theme 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictTheme(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictTheme(node: unknown): asserts node is Theme {
+  if (!isStrictTheme(node)) {
+    throw new Error(`Theme 节点严格断言失败`);
   }
 }
 
@@ -5738,23 +6514,6 @@ export function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic
   }
 }
 
-/**
- * 严格断言为 BusinessLogic 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic {
-  if (!isStrictBusinessLogic(node)) {
-    throw new Error(`BusinessLogic 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 AuthLogicForCallInterface 节点
  *
@@ -5789,6 +6548,23 @@ export function assertStrictOverriddenLogic(node: unknown): asserts node is Over
   }
 }
 
+/**
+ * 严格断言为 BusinessLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic {
+  if (!isStrictBusinessLogic(node)) {
+    throw new Error(`BusinessLogic 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 Param 节点
  *
@@ -6475,14 +7251,31 @@ export function assertStrictStringLiteral(node: unknown): asserts node is String
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictStringInterpolation(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringInterpolation 类型
+ * assertStrictStringInterpolation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringInterpolation 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictStringInterpolation(node: unknown): asserts node is StringInterpolation {
+  if (!isStrictStringInterpolation(node)) {
+    throw new Error(`StringInterpolation 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 StaticString 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictStaticString(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictStringInterpolation(node: unknown): asserts node is StringInterpolation {
-  if (!isStrictStringInterpolation(node)) {
-    throw new Error(`StringInterpolation 节点严格断言失败`);
+export function assertStrictStaticString(node: unknown): asserts node is StaticString {
+  if (!isStrictStaticString(node)) {
+    throw new Error(`StaticString 节点严格断言失败`);
   }
 }
 
@@ -6673,6 +7466,23 @@ export function assertStrictNewMap(node: unknown): asserts node is NewMap {
   }
 }
 
+/**
+ * 严格断言为 Paginate 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictPaginate(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictPaginate(node: unknown): asserts node is Paginate {
+  if (!isStrictPaginate(node)) {
+    throw new Error(`Paginate 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 CallQueryComponent 节点
  *
@@ -6912,104 +7722,87 @@ export function assertStrictProcessComponent(node: unknown): asserts node is Pro
 }
 
 /**
- * 严格断言为 ProcessOutcome 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictProcessOutcome(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictProcessOutcome(node: unknown): asserts node is ProcessOutcome {
-  if (!isStrictProcessOutcome(node)) {
-    throw new Error(`ProcessOutcome 节点严格断言失败`);
-  }
-}
-
-/**
- * 严格断言为 Assignee 节点
+ * 严格断言为 SequentialPolicy 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictAssignee(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 类型
+ * assertStrictSequentialPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictAssignee(node: unknown): asserts node is Assignee {
-  if (!isStrictAssignee(node)) {
-    throw new Error(`Assignee 节点严格断言失败`);
+export function assertStrictSequentialPolicy(node: unknown): asserts node is SequentialPolicy {
+  if (!isStrictSequentialPolicy(node)) {
+    throw new Error(`SequentialPolicy 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 ProcessOutcomes 节点
+ * 严格断言为 CountersignPolicy 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictProcessOutcomes(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 类型
+ * assertStrictCountersignPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictProcessOutcomes(node: unknown): asserts node is ProcessOutcomes {
-  if (!isStrictProcessOutcomes(node)) {
-    throw new Error(`ProcessOutcomes 节点严格断言失败`);
+export function assertStrictCountersignPolicy(node: unknown): asserts node is CountersignPolicy {
+  if (!isStrictCountersignPolicy(node)) {
+    throw new Error(`CountersignPolicy 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 MultiApprovalPolicy 节点
+ * 严格断言为 ProcessOutcome 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictMultiApprovalPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 类型
+ * assertStrictProcessOutcome(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictMultiApprovalPolicy(node: unknown): asserts node is MultiApprovalPolicy {
-  if (!isStrictMultiApprovalPolicy(node)) {
-    throw new Error(`MultiApprovalPolicy 节点严格断言失败`);
+export function assertStrictProcessOutcome(node: unknown): asserts node is ProcessOutcome {
+  if (!isStrictProcessOutcome(node)) {
+    throw new Error(`ProcessOutcome 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 SequentialPolicy 节点
+ * 严格断言为 Assignee 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSequentialPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 类型
+ * assertStrictAssignee(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictSequentialPolicy(node: unknown): asserts node is SequentialPolicy {
-  if (!isStrictSequentialPolicy(node)) {
-    throw new Error(`SequentialPolicy 节点严格断言失败`);
+export function assertStrictAssignee(node: unknown): asserts node is Assignee {
+  if (!isStrictAssignee(node)) {
+    throw new Error(`Assignee 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 CountersignPolicy 节点
+ * 严格断言为 ProcessOutcomes 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictCountersignPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 类型
+ * assertStrictProcessOutcomes(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictCountersignPolicy(node: unknown): asserts node is CountersignPolicy {
-  if (!isStrictCountersignPolicy(node)) {
-    throw new Error(`CountersignPolicy 节点严格断言失败`);
+export function assertStrictProcessOutcomes(node: unknown): asserts node is ProcessOutcomes {
+  if (!isStrictProcessOutcomes(node)) {
+    throw new Error(`ProcessOutcomes 节点严格断言失败`);
   }
 }
 
@@ -7251,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 节点
  *
@@ -7455,7 +8265,7 @@ export function assertApp(node: unknown): asserts node is App {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertModule(node: unknown): asserts node is Type.ModuleNode {
+export function assertModule(node: unknown): asserts node is types.ModuleNode {
   if (!isModule(node)) {
     throw new Error(`Module 节点断言失败`);
   }
@@ -7815,99 +8625,297 @@ export function assertView(node: unknown): asserts node is View {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertViewElement(node: unknown): asserts node is ViewElement {
-  if (!isViewElement(node)) {
-    throw new Error(`ViewElement 节点断言失败`);
+export function assertViewElement(node: unknown): asserts node is ViewElement {
+  if (!isViewElement(node)) {
+    throw new Error(`ViewElement 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 BindAttribute 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBindAttribute`方法
+ * @example
+ * ```ts
+ * assertBindAttribute(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 或者 BindAttribute 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBindAttribute(node: unknown): asserts node is BindAttribute {
+  if (!isBindAttribute(node)) {
+    throw new Error(`BindAttribute 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 BindDirective 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBindDirective`方法
+ * @example
+ * ```ts
+ * assertBindDirective(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 或者 BindDirective 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBindDirective(node: unknown): asserts node is BindDirective {
+  if (!isBindDirective(node)) {
+    throw new Error(`BindDirective 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 BindEvent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBindEvent`方法
+ * @example
+ * ```ts
+ * assertBindEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 或者 BindEvent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBindEvent(node: unknown): asserts node is BindEvent {
+  if (!isBindEvent(node)) {
+    throw new Error(`BindEvent 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 BindStyle 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBindStyle`方法
+ * @example
+ * ```ts
+ * assertBindStyle(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 或者 BindStyle 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBindStyle(node: unknown): asserts node is BindStyle {
+  if (!isBindStyle(node)) {
+    throw new Error(`BindStyle 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 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 节点断言失败`);
   }
 }
 
 /**
- * 断言为 BindAttribute 节点
+ * 断言为 NumberInputSetter 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBindAttribute`方法
+ * @description 节点没有继承类时，等价于`assertStrictNumberInputSetter`方法
  * @example
  * ```ts
- * assertBindAttribute(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 或者 BindAttribute 继承类型
+ * assertNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 或者 NumberInputSetter 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertBindAttribute(node: unknown): asserts node is BindAttribute {
-  if (!isBindAttribute(node)) {
-    throw new Error(`BindAttribute 节点断言失败`);
+export function assertNumberInputSetter(node: unknown): asserts node is NumberInputSetter {
+  if (!isNumberInputSetter(node)) {
+    throw new Error(`NumberInputSetter 节点断言失败`);
   }
 }
 
 /**
- * 断言为 BindDirective 节点
+ * 断言为 IconSetter 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBindDirective`方法
+ * @description 节点没有继承类时，等价于`assertStrictIconSetter`方法
  * @example
  * ```ts
- * assertBindDirective(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 或者 BindDirective 继承类型
+ * assertIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 或者 IconSetter 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertBindDirective(node: unknown): asserts node is BindDirective {
-  if (!isBindDirective(node)) {
-    throw new Error(`BindDirective 节点断言失败`);
+export function assertIconSetter(node: unknown): asserts node is IconSetter {
+  if (!isIconSetter(node)) {
+    throw new Error(`IconSetter 节点断言失败`);
   }
 }
 
 /**
- * 断言为 BindEvent 节点
+ * 断言为 ImageSetter 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBindEvent`方法
+ * @description 节点没有继承类时，等价于`assertStrictImageSetter`方法
  * @example
  * ```ts
- * assertBindEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 或者 BindEvent 继承类型
+ * assertImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 或者 ImageSetter 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertBindEvent(node: unknown): asserts node is BindEvent {
-  if (!isBindEvent(node)) {
-    throw new Error(`BindEvent 节点断言失败`);
+export function assertImageSetter(node: unknown): asserts node is ImageSetter {
+  if (!isImageSetter(node)) {
+    throw new Error(`ImageSetter 节点断言失败`);
   }
 }
 
 /**
- * 断言为 BindStyle 节点
+ * 断言为 PropertySelectSetter 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBindStyle`方法
+ * @description 节点没有继承类时，等价于`assertStrictPropertySelectSetter`方法
  * @example
  * ```ts
- * assertBindStyle(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 或者 BindStyle 继承类型
+ * assertPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 或者 PropertySelectSetter 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertBindStyle(node: unknown): asserts node is BindStyle {
-  if (!isBindStyle(node)) {
-    throw new Error(`BindStyle 节点断言失败`);
+export function assertPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter {
+  if (!isPropertySelectSetter(node)) {
+    throw new Error(`PropertySelectSetter 节点断言失败`);
   }
 }
 
 /**
- * 断言为 ViewComponent 节点
+ * 断言为 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 节点断言失败`);
   }
 }
 
@@ -7966,56 +8974,92 @@ export function assertEvent(node: unknown): asserts node is Event {
 }
 
 /**
- * 断言为 Slot 节点
+ * 断言为 PropDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictSlot`方法
+ * @description 节点没有继承类时，等价于`assertStrictPropDeclaration`方法
  * @example
  * ```ts
- * assertSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 或者 Slot 继承类型
+ * assertPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 或者 PropDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertSlot(node: unknown): asserts node is Slot {
-  if (!isSlot(node)) {
-    throw new Error(`Slot 节点断言失败`);
+export function assertPropDeclaration(node: unknown): asserts node is PropDeclaration {
+  if (!isPropDeclaration(node)) {
+    throw new Error(`PropDeclaration 节点断言失败`);
   }
 }
 
 /**
- * 断言为 Theme 节点
+ * 断言为 EventDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictTheme`方法
+ * @description 节点没有继承类时，等价于`assertStrictEventDeclaration`方法
  * @example
  * ```ts
- * assertTheme(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 或者 Theme 继承类型
+ * assertEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 或者 EventDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertTheme(node: unknown): asserts node is Theme {
-  if (!isTheme(node)) {
-    throw new Error(`Theme 节点断言失败`);
+export function assertEventDeclaration(node: unknown): asserts node is EventDeclaration {
+  if (!isEventDeclaration(node)) {
+    throw new Error(`EventDeclaration 节点断言失败`);
   }
 }
 
 /**
- * 断言为 StaticString 节点
+ * 断言为 SlotDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictStaticString`方法
+ * @description 节点没有继承类时，等价于`assertStrictSlotDeclaration`方法
  * @example
  * ```ts
- * assertStaticString(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 或者 StaticString 继承类型
+ * assertSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 或者 SlotDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStaticString(node: unknown): asserts node is StaticString {
-  if (!isStaticString(node)) {
-    throw new Error(`StaticString 节点断言失败`);
+export function assertSlotDeclaration(node: unknown): asserts node is SlotDeclaration {
+  if (!isSlotDeclaration(node)) {
+    throw new Error(`SlotDeclaration 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 LogicDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictLogicDeclaration`方法
+ * @example
+ * ```ts
+ * assertLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 或者 LogicDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertLogicDeclaration(node: unknown): asserts node is LogicDeclaration {
+  if (!isLogicDeclaration(node)) {
+    throw new Error(`LogicDeclaration 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 Theme 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictTheme`方法
+ * @example
+ * ```ts
+ * assertTheme(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 或者 Theme 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertTheme(node: unknown): asserts node is Theme {
+  if (!isTheme(node)) {
+    throw new Error(`Theme 节点断言失败`);
   }
 }
 
@@ -8031,7 +9075,7 @@ export function assertStaticString(node: unknown): asserts node is StaticString
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertLogic(node: unknown): asserts node is Type.LogicNode {
+export function assertLogic(node: unknown): asserts node is types.LogicNode {
   if (!isLogic(node)) {
     throw new Error(`Logic 节点断言失败`);
   }
@@ -8049,30 +9093,12 @@ export function assertLogic(node: unknown): asserts node is Type.LogicNode {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertAuthLogic(node: unknown): asserts node is Type.AuthLogicNode {
+export function assertAuthLogic(node: unknown): asserts node is types.AuthLogicNode {
   if (!isAuthLogic(node)) {
     throw new Error(`AuthLogic 节点断言失败`);
   }
 }
 
-/**
- * 断言为 BusinessLogic 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
- * @example
- * ```ts
- * assertBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertBusinessLogic(node: unknown): asserts node is BusinessLogic {
-  if (!isBusinessLogic(node)) {
-    throw new Error(`BusinessLogic 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 AuthLogicForCallInterface 节点
  *
@@ -8109,6 +9135,24 @@ export function assertOverriddenLogic(node: unknown): asserts node is Overridden
   }
 }
 
+/**
+ * 断言为 BusinessLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
+ * @example
+ * ```ts
+ * assertBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertBusinessLogic(node: unknown): asserts node is BusinessLogic {
+  if (!isBusinessLogic(node)) {
+    throw new Error(`BusinessLogic 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 AbstractInterface 节点
  *
@@ -8121,7 +9165,7 @@ export function assertOverriddenLogic(node: unknown): asserts node is Overridden
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertAbstractInterface(node: unknown): asserts node is Type.AbstractInterfaceNode {
+export function assertAbstractInterface(node: unknown): asserts node is types.AbstractInterfaceNode {
   if (!isAbstractInterface(node)) {
     throw new Error(`AbstractInterface 节点断言失败`);
   }
@@ -8139,7 +9183,7 @@ export function assertAbstractInterface(node: unknown): asserts node is Type.Abs
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertParam(node: unknown): asserts node is Type.ParamNode {
+export function assertParam(node: unknown): asserts node is types.ParamNode {
   if (!isParam(node)) {
     throw new Error(`Param 节点断言失败`);
   }
@@ -8193,7 +9237,7 @@ export function assertReturn(node: unknown): asserts node is Return {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertVariable(node: unknown): asserts node is Type.VariableNode {
+export function assertVariable(node: unknown): asserts node is types.VariableNode {
   if (!isVariable(node)) {
     throw new Error(`Variable 节点断言失败`);
   }
@@ -8265,7 +9309,7 @@ export function assertConstant(node: unknown): asserts node is Constant {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertLogicItem(node: unknown): asserts node is Type.LogicItemNode {
+export function assertLogicItem(node: unknown): asserts node is types.LogicItemNode {
   if (!isLogicItem(node)) {
     throw new Error(`LogicItem 节点断言失败`);
   }
@@ -8308,38 +9352,38 @@ export function assertAnonymousFunction(node: unknown): asserts node is Anonymou
 }
 
 /**
- * 断言为 Interface 节点
+ * 断言为 ImportedInterface 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictInterface`方法
+ * @description 节点没有继承类时，等价于`assertStrictImportedInterface`方法
  * @example
  * ```ts
- * assertInterface(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 或者 Interface 继承类型
+ * assertImportedInterface(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImportedInterface 或者 ImportedInterface 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertInterface(node: unknown): asserts node is Type.InterfaceNode {
-  if (!isInterface(node)) {
-    throw new Error(`Interface 节点断言失败`);
+export function assertImportedInterface(node: unknown): asserts node is types.ImportedInterfaceNode {
+  if (!isImportedInterface(node)) {
+    throw new Error(`ImportedInterface 节点断言失败`);
   }
 }
 
 /**
- * 断言为 ImportedInterface 节点
+ * 断言为 Interface 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictImportedInterface`方法
+ * @description 节点没有继承类时，等价于`assertStrictInterface`方法
  * @example
  * ```ts
- * assertImportedInterface(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImportedInterface 或者 ImportedInterface 继承类型
+ * assertInterface(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 或者 Interface 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertImportedInterface(node: unknown): asserts node is Type.ImportedInterfaceNode {
-  if (!isImportedInterface(node)) {
-    throw new Error(`ImportedInterface 节点断言失败`);
+export function assertInterface(node: unknown): asserts node is types.InterfaceNode {
+  if (!isInterface(node)) {
+    throw new Error(`Interface 节点断言失败`);
   }
 }
 
@@ -8607,7 +9651,7 @@ export function assertComment(node: unknown): asserts node is Comment {
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertCallLogic(node: unknown): asserts node is Type.CallLogicNode {
+export function assertCallLogic(node: unknown): asserts node is types.CallLogicNode {
   if (!isCallLogic(node)) {
     throw new Error(`CallLogic 节点断言失败`);
   }
@@ -8661,7 +9705,7 @@ export function assertCallFunction(node: unknown): asserts node is CallFunction
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertCallInterface(node: unknown): asserts node is Type.CallInterfaceNode {
+export function assertCallInterface(node: unknown): asserts node is types.CallInterfaceNode {
   if (!isCallInterface(node)) {
     throw new Error(`CallInterface 节点断言失败`);
   }
@@ -8901,6 +9945,24 @@ export function assertStringInterpolation(node: unknown): asserts node is String
   }
 }
 
+/**
+ * 断言为 StaticString 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictStaticString`方法
+ * @example
+ * ```ts
+ * assertStaticString(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 或者 StaticString 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStaticString(node: unknown): asserts node is StaticString {
+  if (!isStaticString(node)) {
+    throw new Error(`StaticString 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 NumericLiteral 节点
  *
@@ -9099,6 +10161,24 @@ export function assertNewMap(node: unknown): asserts node is NewMap {
   }
 }
 
+/**
+ * 断言为 Paginate 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPaginate`方法
+ * @example
+ * ```ts
+ * assertPaginate(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 或者 Paginate 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertPaginate(node: unknown): asserts node is Paginate {
+  if (!isPaginate(node)) {
+    throw new Error(`Paginate 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 CallQueryComponent 节点
  *
@@ -9352,110 +10432,110 @@ export function assertProcessComponent(node: unknown): asserts node is ProcessCo
 }
 
 /**
- * 断言为 ProcessOutcome 节点
+ * 断言为 MultiApprovalPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictProcessOutcome`方法
+ * @description 节点没有继承类时，等价于`assertStrictMultiApprovalPolicy`方法
  * @example
  * ```ts
- * assertProcessOutcome(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 或者 ProcessOutcome 继承类型
+ * assertMultiApprovalPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertProcessOutcome(node: unknown): asserts node is ProcessOutcome {
-  if (!isProcessOutcome(node)) {
-    throw new Error(`ProcessOutcome 节点断言失败`);
+export function assertMultiApprovalPolicy(node: unknown): asserts node is types.MultiApprovalPolicyNode {
+  if (!isMultiApprovalPolicy(node)) {
+    throw new Error(`MultiApprovalPolicy 节点断言失败`);
   }
 }
 
 /**
- * 断言为 Assignee 节点
+ * 断言为 SequentialPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictAssignee`方法
+ * @description 节点没有继承类时，等价于`assertStrictSequentialPolicy`方法
  * @example
  * ```ts
- * assertAssignee(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 或者 Assignee 继承类型
+ * assertSequentialPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 或者 SequentialPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertAssignee(node: unknown): asserts node is Assignee {
-  if (!isAssignee(node)) {
-    throw new Error(`Assignee 节点断言失败`);
+export function assertSequentialPolicy(node: unknown): asserts node is SequentialPolicy {
+  if (!isSequentialPolicy(node)) {
+    throw new Error(`SequentialPolicy 节点断言失败`);
   }
 }
 
 /**
- * 断言为 ProcessOutcomes 节点
+ * 断言为 CountersignPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictProcessOutcomes`方法
+ * @description 节点没有继承类时，等价于`assertStrictCountersignPolicy`方法
  * @example
  * ```ts
- * assertProcessOutcomes(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 或者 ProcessOutcomes 继承类型
+ * assertCountersignPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 或者 CountersignPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertProcessOutcomes(node: unknown): asserts node is ProcessOutcomes {
-  if (!isProcessOutcomes(node)) {
-    throw new Error(`ProcessOutcomes 节点断言失败`);
+export function assertCountersignPolicy(node: unknown): asserts node is CountersignPolicy {
+  if (!isCountersignPolicy(node)) {
+    throw new Error(`CountersignPolicy 节点断言失败`);
   }
 }
 
 /**
- * 断言为 MultiApprovalPolicy 节点
+ * 断言为 ProcessOutcome 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictMultiApprovalPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictProcessOutcome`方法
  * @example
  * ```ts
- * assertMultiApprovalPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
+ * assertProcessOutcome(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 或者 ProcessOutcome 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertMultiApprovalPolicy(node: unknown): asserts node is Type.MultiApprovalPolicyNode {
-  if (!isMultiApprovalPolicy(node)) {
-    throw new Error(`MultiApprovalPolicy 节点断言失败`);
+export function assertProcessOutcome(node: unknown): asserts node is ProcessOutcome {
+  if (!isProcessOutcome(node)) {
+    throw new Error(`ProcessOutcome 节点断言失败`);
   }
 }
 
 /**
- * 断言为 SequentialPolicy 节点
+ * 断言为 Assignee 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictSequentialPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictAssignee`方法
  * @example
  * ```ts
- * assertSequentialPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 或者 SequentialPolicy 继承类型
+ * assertAssignee(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 或者 Assignee 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertSequentialPolicy(node: unknown): asserts node is SequentialPolicy {
-  if (!isSequentialPolicy(node)) {
-    throw new Error(`SequentialPolicy 节点断言失败`);
+export function assertAssignee(node: unknown): asserts node is Assignee {
+  if (!isAssignee(node)) {
+    throw new Error(`Assignee 节点断言失败`);
   }
 }
 
 /**
- * 断言为 CountersignPolicy 节点
+ * 断言为 ProcessOutcomes 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictCountersignPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictProcessOutcomes`方法
  * @example
  * ```ts
- * assertCountersignPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 或者 CountersignPolicy 继承类型
+ * assertProcessOutcomes(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 或者 ProcessOutcomes 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertCountersignPolicy(node: unknown): asserts node is CountersignPolicy {
-  if (!isCountersignPolicy(node)) {
-    throw new Error(`CountersignPolicy 节点断言失败`);
+export function assertProcessOutcomes(node: unknown): asserts node is ProcessOutcomes {
+  if (!isProcessOutcomes(node)) {
+    throw new Error(`ProcessOutcomes 节点断言失败`);
   }
 }
 
@@ -9705,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 节点
  *
@@ -9759,7 +10857,7 @@ export function assertCallAuthInterface(node: unknown): asserts node is CallAuth
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertTriggerEvent(node: unknown): asserts node is Type.TriggerEventNode {
+export function assertTriggerEvent(node: unknown): asserts node is types.TriggerEventNode {
   if (!isTriggerEvent(node)) {
     throw new Error(`TriggerEvent 节点断言失败`);
   }
@@ -9813,7 +10911,7 @@ export function assertConnectorTrigger(node: unknown): asserts node is Connector
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertTriggerLauncher(node: unknown): asserts node is Type.TriggerLauncherNode {
+export function assertTriggerLauncher(node: unknown): asserts node is types.TriggerLauncherNode {
   if (!isTriggerLauncher(node)) {
     throw new Error(`TriggerLauncher 节点断言失败`);
   }