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

package/out/concepts/utils/asserts.d.ts

@@ -24,18 +24,30 @@ 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 { 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 { Param } from '../Param__';
 import type { ParamWithGroup } from '../ParamWithGroup__';
 import type { Return } from '../Return__';
@@ -77,6 +89,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__';
@@ -88,6 +101,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__';
@@ -102,12 +116,11 @@ import type { OqlQueryComponent } from '../OqlQueryComponent__';
 import type { Process } from '../Process__';
 import type { ProcessElement } from '../ProcessElement__';
 import type { ProcessComponent } from '../ProcessComponent__';
+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 { MultiApprovalPolicy } from '../MultiApprovalPolicy__';
-import type { SequentialPolicy } from '../SequentialPolicy__';
-import type { CountersignPolicy } from '../CountersignPolicy__';
 import type { Role } from '../Role__';
 import type { Configuration } from '../Configuration__';
 import type { ConfigGroup } from '../ConfigGroup__';
@@ -122,6 +135,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__';
@@ -132,7 +146,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';
 /**
@@ -464,17 +478,137 @@ export declare function isStrictBindEvent(node: unknown): node is BindEvent;
  */
 export declare function isStrictBindStyle(node: unknown): node is BindStyle;
 /**
- * 严格判断输入为 ViewComponent 节点
+ * 严格判断输入为 ThemeVariable 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型为 ThemeVariable
+ * }
+ * ```
+ */
+export declare function isStrictThemeVariable(node: unknown): node is ThemeVariable;
+/**
+ * 严格判断输入为 InputSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 InputSetter
+ * }
+ * ```
+ */
+export declare function isStrictInputSetter(node: unknown): node is InputSetter;
+/**
+ * 严格判断输入为 SwitchSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSwitchSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 SwitchSetter
+ * }
+ * ```
+ */
+export declare function isStrictSwitchSetter(node: unknown): node is SwitchSetter;
+/**
+ * 严格判断输入为 SetterOption 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSetterOption(node)) {
+ *   // 在这个花括号内，node 的类型为 SetterOption
+ * }
+ * ```
+ */
+export declare function isStrictSetterOption(node: unknown): node is SetterOption;
+/**
+ * 严格判断输入为 EnumSelectSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictEnumSelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 EnumSelectSetter
+ * }
+ * ```
+ */
+export declare function isStrictEnumSelectSetter(node: unknown): node is EnumSelectSetter;
+/**
+ * 严格判断输入为 CapsulesSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 CapsulesSetter
+ * }
+ * ```
+ */
+export declare function isStrictCapsulesSetter(node: unknown): node is CapsulesSetter;
+/**
+ * 严格判断输入为 NumberInputSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 NumberInputSetter
+ * }
+ * ```
+ */
+export declare function isStrictNumberInputSetter(node: unknown): node is NumberInputSetter;
+/**
+ * 严格判断输入为 IconSetter 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictViewComponent(node)) {
- *   // 在这个花括号内，node 的类型为 ViewComponent
+ * if (isStrictIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 IconSetter
  * }
  * ```
  */
-export declare function isStrictViewComponent(node: unknown): node is ViewComponent;
+export declare function isStrictIconSetter(node: unknown): node is IconSetter;
+/**
+ * 严格判断输入为 ImageSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 ImageSetter
+ * }
+ * ```
+ */
+export declare function isStrictImageSetter(node: unknown): node is ImageSetter;
+/**
+ * 严格判断输入为 PropertySelectSetter 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictPropertySelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 PropertySelectSetter
+ * }
+ * ```
+ */
+export declare function isStrictPropertySelectSetter(node: unknown): node is PropertySelectSetter;
+/**
+ * 严格判断输入为 ViewComponentDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 ViewComponentDeclaration
+ * }
+ * ```
+ */
+export declare function isStrictViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration;
 /**
  * 严格判断输入为 BusinessComponent 节点
  *
@@ -512,77 +646,89 @@ export declare function isStrictAttribute(node: unknown): node is Attribute;
  */
 export declare function isStrictEvent(node: unknown): node is Event;
 /**
- * 严格判断输入为 Slot 节点
+ * 严格判断输入为 PropDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictSlot(node)) {
- *   // 在这个花括号内，node 的类型为 Slot
+ * if (isStrictPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 PropDeclaration
  * }
  * ```
  */
-export declare function isStrictSlot(node: unknown): node is Slot;
+export declare function isStrictPropDeclaration(node: unknown): node is PropDeclaration;
 /**
- * 严格判断输入为 Theme 节点
+ * 严格判断输入为 EventDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictTheme(node)) {
- *   // 在这个花括号内，node 的类型为 Theme
+ * if (isStrictEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 EventDeclaration
  * }
  * ```
  */
-export declare function isStrictTheme(node: unknown): node is Theme;
+export declare function isStrictEventDeclaration(node: unknown): node is EventDeclaration;
 /**
- * 严格判断输入为 StaticString 节点
+ * 严格判断输入为 SlotDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictStaticString(node)) {
- *   // 在这个花括号内，node 的类型为 StaticString
+ * if (isStrictSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 SlotDeclaration
  * }
  * ```
  */
-export declare function isStrictStaticString(node: unknown): node is StaticString;
+export declare function isStrictSlotDeclaration(node: unknown): node is SlotDeclaration;
 /**
- * 严格判断输入为 Logic 节点
+ * 严格判断输入为 LogicDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictLogic(node)) {
- *   // 在这个花括号内，node 的类型为 Logic
+ * if (isStrictLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 LogicDeclaration
  * }
  * ```
  */
-export declare function isStrictLogic(node: unknown): node is Logic;
+export declare function isStrictLogicDeclaration(node: unknown): node is LogicDeclaration;
 /**
- * 严格判断输入为 AuthLogic 节点
+ * 严格判断输入为 Theme 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictAuthLogic(node)) {
- *   // 在这个花括号内，node 的类型为 AuthLogic
+ * if (isStrictTheme(node)) {
+ *   // 在这个花括号内，node 的类型为 Theme
  * }
  * ```
  */
-export declare function isStrictAuthLogic(node: unknown): node is AuthLogic;
+export declare function isStrictTheme(node: unknown): node is Theme;
 /**
- * 严格判断输入为 BusinessLogic 节点
+ * 严格判断输入为 Logic 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * if (isStrictLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 Logic
  * }
  * ```
  */
-export declare function isStrictBusinessLogic(node: unknown): node is BusinessLogic;
+export declare function isStrictLogic(node: unknown): node is Logic;
+/**
+ * 严格判断输入为 AuthLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAuthLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 AuthLogic
+ * }
+ * ```
+ */
+export declare function isStrictAuthLogic(node: unknown): node is AuthLogic;
 /**
  * 严格判断输入为 AuthLogicForCallInterface 节点
  *
@@ -607,6 +753,18 @@ export declare function isStrictAuthLogicForCallInterface(node: unknown): node i
  * ```
  */
 export declare function isStrictOverriddenLogic(node: unknown): node is OverriddenLogic;
+/**
+ * 严格判断输入为 BusinessLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * }
+ * ```
+ */
+export declare function isStrictBusinessLogic(node: unknown): node is BusinessLogic;
 /**
  * 严格判断输入为 Param 节点
  *
@@ -1099,6 +1257,18 @@ export declare function isStrictStringLiteral(node: unknown): node is StringLite
  * ```
  */
 export declare function isStrictStringInterpolation(node: unknown): node is StringInterpolation;
+/**
+ * 严格判断输入为 StaticString 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictStaticString(node)) {
+ *   // 在这个花括号内，node 的类型为 StaticString
+ * }
+ * ```
+ */
+export declare function isStrictStaticString(node: unknown): node is StaticString;
 /**
  * 严格判断输入为 NumericLiteral 节点
  *
@@ -1231,6 +1401,18 @@ export declare function isStrictNewList(node: unknown): node is NewList;
  * ```
  */
 export declare function isStrictNewMap(node: unknown): node is NewMap;
+/**
+ * 严格判断输入为 Paginate 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictPaginate(node)) {
+ *   // 在这个花括号内，node 的类型为 Paginate
+ * }
+ * ```
+ */
+export declare function isStrictPaginate(node: unknown): node is Paginate;
 /**
  * 严格判断输入为 CallQueryComponent 节点
  *
@@ -1400,77 +1582,65 @@ export declare function isStrictProcessElement(node: unknown): node is ProcessEl
  */
 export declare function isStrictProcessComponent(node: unknown): node is ProcessComponent;
 /**
- * 严格判断输入为 ProcessOutcome 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictProcessOutcome(node)) {
- *   // 在这个花括号内，node 的类型为 ProcessOutcome
- * }
- * ```
- */
-export declare function isStrictProcessOutcome(node: unknown): node is ProcessOutcome;
-/**
- * 严格判断输入为 Assignee 节点
+ * 严格判断输入为 SequentialPolicy 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictAssignee(node)) {
- *   // 在这个花括号内，node 的类型为 Assignee
+ * if (isStrictSequentialPolicy(node)) {
+ *   // 在这个花括号内，node 的类型为 SequentialPolicy
  * }
  * ```
  */
-export declare function isStrictAssignee(node: unknown): node is Assignee;
+export declare function isStrictSequentialPolicy(node: unknown): node is SequentialPolicy;
 /**
- * 严格判断输入为 ProcessOutcomes 节点
+ * 严格判断输入为 CountersignPolicy 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictProcessOutcomes(node)) {
- *   // 在这个花括号内，node 的类型为 ProcessOutcomes
+ * if (isStrictCountersignPolicy(node)) {
+ *   // 在这个花括号内，node 的类型为 CountersignPolicy
  * }
  * ```
  */
-export declare function isStrictProcessOutcomes(node: unknown): node is ProcessOutcomes;
+export declare function isStrictCountersignPolicy(node: unknown): node is CountersignPolicy;
 /**
- * 严格判断输入为 MultiApprovalPolicy 节点
+ * 严格判断输入为 ProcessOutcome 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictMultiApprovalPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 MultiApprovalPolicy
+ * if (isStrictProcessOutcome(node)) {
+ *   // 在这个花括号内，node 的类型为 ProcessOutcome
  * }
  * ```
  */
-export declare function isStrictMultiApprovalPolicy(node: unknown): node is MultiApprovalPolicy;
+export declare function isStrictProcessOutcome(node: unknown): node is ProcessOutcome;
 /**
- * 严格判断输入为 SequentialPolicy 节点
+ * 严格判断输入为 Assignee 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictSequentialPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 SequentialPolicy
+ * if (isStrictAssignee(node)) {
+ *   // 在这个花括号内，node 的类型为 Assignee
  * }
  * ```
  */
-export declare function isStrictSequentialPolicy(node: unknown): node is SequentialPolicy;
+export declare function isStrictAssignee(node: unknown): node is Assignee;
 /**
- * 严格判断输入为 CountersignPolicy 节点
+ * 严格判断输入为 ProcessOutcomes 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictCountersignPolicy(node)) {
- *   // 在这个花括号内，node 的类型为 CountersignPolicy
+ * if (isStrictProcessOutcomes(node)) {
+ *   // 在这个花括号内，node 的类型为 ProcessOutcomes
  * }
  * ```
  */
-export declare function isStrictCountersignPolicy(node: unknown): node is CountersignPolicy;
+export declare function isStrictProcessOutcomes(node: unknown): node is ProcessOutcomes;
 /**
  * 严格判断输入为 Role 节点
  *
@@ -1639,6 +1809,18 @@ export declare function isStrictFrontendLibrary(node: unknown): node is Frontend
  * ```
  */
 export declare function isStrictViewBlock(node: unknown): node is ViewBlock;
+/**
+ * 严格判断输入为 ViewBlockWithImage 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictViewBlockWithImage(node)) {
+ *   // 在这个花括号内，node 的类型为 ViewBlockWithImage
+ * }
+ * ```
+ */
+export declare function isStrictViewBlockWithImage(node: unknown): node is ViewBlockWithImage;
 /**
  * 严格判断输入为 AuthInterface 节点
  *
@@ -1784,7 +1966,7 @@ export declare function isApp(node: unknown): node is App;
  * }
  * ```
  */
-export declare function isModule(node: unknown): node is Type.ModuleNode;
+export declare function isModule(node: unknown): node is types.ModuleNode;
 /**
  * 判断输入为 Namespace 节点实例
  *
@@ -2098,137 +2280,293 @@ export declare function isBindEvent(node: unknown): node is BindEvent;
  */
 export declare function isBindStyle(node: unknown): node is BindStyle;
 /**
- * 判断输入为 ViewComponent 节点实例
+ * 判断输入为 ThemeVariable 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewComponent 节点没有继承类，此判断等价于`isStrictViewComponent`
+ * @description 等价于`instanceof`运算，ThemeVariable 节点没有继承类，此判断等价于`isStrictThemeVariable`
  * @example
  * ```ts
- * if (isViewComponent(node)) {
- *   // 在这个花括号内，node 的类型是 ViewComponent 或者 ViewComponent 继承类型
+ * if (isThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型是 ThemeVariable 或者 ThemeVariable 继承类型
  * }
  * ```
  */
-export declare function isViewComponent(node: unknown): node is ViewComponent;
+export declare function isThemeVariable(node: unknown): node is ThemeVariable;
 /**
- * 判断输入为 BusinessComponent 节点实例
+ * 判断输入为 BaseSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isBusinessComponent(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
+ * if (isBaseSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 BaseSetter 或者 BaseSetter 继承类型
  * }
  * ```
  */
-export declare function isBusinessComponent(node: unknown): node is BusinessComponent;
+export declare function isBaseSetter(node: unknown): node is types.BaseSetterNode;
 /**
- * 判断输入为 Attribute 节点实例
+ * 判断输入为 InputSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Attribute 节点没有继承类，此判断等价于`isStrictAttribute`
+ * @description 等价于`instanceof`运算，InputSetter 节点没有继承类，此判断等价于`isStrictInputSetter`
  * @example
  * ```ts
- * if (isAttribute(node)) {
- *   // 在这个花括号内，node 的类型是 Attribute 或者 Attribute 继承类型
+ * if (isInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 InputSetter 或者 InputSetter 继承类型
  * }
  * ```
  */
-export declare function isAttribute(node: unknown): node is Attribute;
+export declare function isInputSetter(node: unknown): node is InputSetter;
 /**
- * 判断输入为 Event 节点实例
+ * 判断输入为 SwitchSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Event 节点没有继承类，此判断等价于`isStrictEvent`
+ * @description 等价于`instanceof`运算，SwitchSetter 节点没有继承类，此判断等价于`isStrictSwitchSetter`
  * @example
  * ```ts
- * if (isEvent(node)) {
- *   // 在这个花括号内，node 的类型是 Event 或者 Event 继承类型
+ * if (isSwitchSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 SwitchSetter 或者 SwitchSetter 继承类型
  * }
  * ```
  */
-export declare function isEvent(node: unknown): node is Event;
+export declare function isSwitchSetter(node: unknown): node is SwitchSetter;
 /**
- * 判断输入为 Slot 节点实例
+ * 判断输入为 SetterOption 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Slot 节点没有继承类，此判断等价于`isStrictSlot`
+ * @description 等价于`instanceof`运算，SetterOption 节点没有继承类，此判断等价于`isStrictSetterOption`
  * @example
  * ```ts
- * if (isSlot(node)) {
- *   // 在这个花括号内，node 的类型是 Slot 或者 Slot 继承类型
+ * if (isSetterOption(node)) {
+ *   // 在这个花括号内，node 的类型是 SetterOption 或者 SetterOption 继承类型
  * }
  * ```
  */
-export declare function isSlot(node: unknown): node is Slot;
+export declare function isSetterOption(node: unknown): node is SetterOption;
 /**
- * 判断输入为 Theme 节点实例
+ * 判断输入为 EnumSelectSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Theme 节点没有继承类，此判断等价于`isStrictTheme`
+ * @description 等价于`instanceof`运算，EnumSelectSetter 节点没有继承类，此判断等价于`isStrictEnumSelectSetter`
  * @example
  * ```ts
- * if (isTheme(node)) {
- *   // 在这个花括号内，node 的类型是 Theme 或者 Theme 继承类型
+ * if (isEnumSelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 EnumSelectSetter 或者 EnumSelectSetter 继承类型
  * }
  * ```
  */
-export declare function isTheme(node: unknown): node is Theme;
+export declare function isEnumSelectSetter(node: unknown): node is EnumSelectSetter;
 /**
- * 判断输入为 StaticString 节点实例
+ * 判断输入为 CapsulesSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，StaticString 节点没有继承类，此判断等价于`isStrictStaticString`
+ * @description 等价于`instanceof`运算，CapsulesSetter 节点没有继承类，此判断等价于`isStrictCapsulesSetter`
  * @example
  * ```ts
- * if (isStaticString(node)) {
- *   // 在这个花括号内，node 的类型是 StaticString 或者 StaticString 继承类型
+ * if (isCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 CapsulesSetter 或者 CapsulesSetter 继承类型
  * }
  * ```
  */
-export declare function isStaticString(node: unknown): node is StaticString;
+export declare function isCapsulesSetter(node: unknown): node is CapsulesSetter;
 /**
- * 判断输入为 Logic 节点实例
+ * 判断输入为 NumberInputSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算
+ * @description 等价于`instanceof`运算，NumberInputSetter 节点没有继承类，此判断等价于`isStrictNumberInputSetter`
  * @example
  * ```ts
- * if (isLogic(node)) {
- *   // 在这个花括号内，node 的类型是 Logic 或者 Logic 继承类型
+ * if (isNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 NumberInputSetter 或者 NumberInputSetter 继承类型
  * }
  * ```
  */
-export declare function isLogic(node: unknown): node is Type.LogicNode;
+export declare function isNumberInputSetter(node: unknown): node is NumberInputSetter;
 /**
- * 判断输入为 AuthLogic 节点实例
+ * 判断输入为 IconSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算
+ * @description 等价于`instanceof`运算，IconSetter 节点没有继承类，此判断等价于`isStrictIconSetter`
  * @example
  * ```ts
- * if (isAuthLogic(node)) {
- *   // 在这个花括号内，node 的类型是 AuthLogic 或者 AuthLogic 继承类型
+ * if (isIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 IconSetter 或者 IconSetter 继承类型
  * }
  * ```
  */
-export declare function isAuthLogic(node: unknown): node is Type.AuthLogicNode;
+export declare function isIconSetter(node: unknown): node is IconSetter;
 /**
- * 判断输入为 BusinessLogic 节点实例
+ * 判断输入为 ImageSetter 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @description 等价于`instanceof`运算，ImageSetter 节点没有继承类，此判断等价于`isStrictImageSetter`
  * @example
  * ```ts
- * if (isBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * if (isImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 ImageSetter 或者 ImageSetter 继承类型
  * }
  * ```
  */
-export declare function isBusinessLogic(node: unknown): node is BusinessLogic;
+export declare function isImageSetter(node: unknown): node is ImageSetter;
 /**
- * 判断输入为 AuthLogicForCallInterface 节点实例
+ * 判断输入为 PropertySelectSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，PropertySelectSetter 节点没有继承类，此判断等价于`isStrictPropertySelectSetter`
+ * @example
+ * ```ts
+ * if (isPropertySelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 PropertySelectSetter 或者 PropertySelectSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isPropertySelectSetter(node: unknown): node is PropertySelectSetter;
+/**
+ * 判断输入为 ViewComponentDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ViewComponentDeclaration 节点没有继承类，此判断等价于`isStrictViewComponentDeclaration`
+ * @example
+ * ```ts
+ * if (isViewComponentDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
+ * }
+ * ```
+ */
+export declare function isViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration;
+/**
+ * 判断输入为 BusinessComponent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
+ * @example
+ * ```ts
+ * if (isBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
+ * }
+ * ```
+ */
+export declare function isBusinessComponent(node: unknown): node is BusinessComponent;
+/**
+ * 判断输入为 Attribute 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Attribute 节点没有继承类，此判断等价于`isStrictAttribute`
+ * @example
+ * ```ts
+ * if (isAttribute(node)) {
+ *   // 在这个花括号内，node 的类型是 Attribute 或者 Attribute 继承类型
+ * }
+ * ```
+ */
+export declare function isAttribute(node: unknown): node is Attribute;
+/**
+ * 判断输入为 Event 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Event 节点没有继承类，此判断等价于`isStrictEvent`
+ * @example
+ * ```ts
+ * if (isEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 Event 或者 Event 继承类型
+ * }
+ * ```
+ */
+export declare function isEvent(node: unknown): node is Event;
+/**
+ * 判断输入为 PropDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，PropDeclaration 节点没有继承类，此判断等价于`isStrictPropDeclaration`
+ * @example
+ * ```ts
+ * if (isPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 PropDeclaration 或者 PropDeclaration 继承类型
+ * }
+ * ```
+ */
+export declare function isPropDeclaration(node: unknown): node is PropDeclaration;
+/**
+ * 判断输入为 EventDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，EventDeclaration 节点没有继承类，此判断等价于`isStrictEventDeclaration`
+ * @example
+ * ```ts
+ * if (isEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 EventDeclaration 或者 EventDeclaration 继承类型
+ * }
+ * ```
+ */
+export declare function isEventDeclaration(node: unknown): node is EventDeclaration;
+/**
+ * 判断输入为 SlotDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SlotDeclaration 节点没有继承类，此判断等价于`isStrictSlotDeclaration`
+ * @example
+ * ```ts
+ * if (isSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 SlotDeclaration 或者 SlotDeclaration 继承类型
+ * }
+ * ```
+ */
+export declare function isSlotDeclaration(node: unknown): node is SlotDeclaration;
+/**
+ * 判断输入为 LogicDeclaration 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，LogicDeclaration 节点没有继承类，此判断等价于`isStrictLogicDeclaration`
+ * @example
+ * ```ts
+ * if (isLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 LogicDeclaration 或者 LogicDeclaration 继承类型
+ * }
+ * ```
+ */
+export declare function isLogicDeclaration(node: unknown): node is LogicDeclaration;
+/**
+ * 判断输入为 Theme 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Theme 节点没有继承类，此判断等价于`isStrictTheme`
+ * @example
+ * ```ts
+ * if (isTheme(node)) {
+ *   // 在这个花括号内，node 的类型是 Theme 或者 Theme 继承类型
+ * }
+ * ```
+ */
+export declare function isTheme(node: unknown): node is Theme;
+/**
+ * 判断输入为 Logic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 Logic 或者 Logic 继承类型
+ * }
+ * ```
+ */
+export declare function isLogic(node: unknown): node is types.LogicNode;
+/**
+ * 判断输入为 AuthLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isAuthLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 AuthLogic 或者 AuthLogic 继承类型
+ * }
+ * ```
+ */
+export declare function isAuthLogic(node: unknown): node is types.AuthLogicNode;
+/**
+ * 判断输入为 AuthLogicForCallInterface 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
  * @description 等价于`instanceof`运算，AuthLogicForCallInterface 节点没有继承类，此判断等价于`isStrictAuthLogicForCallInterface`
@@ -2253,6 +2591,19 @@ export declare function isAuthLogicForCallInterface(node: unknown): node is Auth
  * ```
  */
 export declare function isOverriddenLogic(node: unknown): node is OverriddenLogic;
+/**
+ * 判断输入为 BusinessLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @example
+ * ```ts
+ * if (isBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * }
+ * ```
+ */
+export declare function isBusinessLogic(node: unknown): node is BusinessLogic;
 /**
  * 判断输入为 AbstractInterface 节点实例
  *
@@ -2265,7 +2616,7 @@ export declare function isOverriddenLogic(node: unknown): node is OverriddenLogi
  * }
  * ```
  */
-export declare function isAbstractInterface(node: unknown): node is Type.AbstractInterfaceNode;
+export declare function isAbstractInterface(node: unknown): node is types.AbstractInterfaceNode;
 /**
  * 判断输入为 Param 节点实例
  *
@@ -2278,7 +2629,7 @@ export declare function isAbstractInterface(node: unknown): node is Type.Abstrac
  * }
  * ```
  */
-export declare function isParam(node: unknown): node is Type.ParamNode;
+export declare function isParam(node: unknown): node is types.ParamNode;
 /**
  * 判断输入为 ParamWithGroup 节点实例
  *
@@ -2317,7 +2668,7 @@ export declare function isReturn(node: unknown): node is Return;
  * }
  * ```
  */
-export declare function isVariable(node: unknown): node is Type.VariableNode;
+export declare function isVariable(node: unknown): node is types.VariableNode;
 /**
  * 判断输入为 BackendVariable 节点实例
  *
@@ -2369,7 +2720,7 @@ export declare function isConstant(node: unknown): node is Constant;
  * }
  * ```
  */
-export declare function isLogicItem(node: unknown): node is Type.LogicItemNode;
+export declare function isLogicItem(node: unknown): node is types.LogicItemNode;
 /**
  * 判断输入为 Function 节点实例
  *
@@ -2397,31 +2748,31 @@ export declare function isFunction(node: unknown): node is Function;
  */
 export declare 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 declare function isInterface(node: unknown): node is Type.InterfaceNode;
+export declare function isImportedInterface(node: unknown): node is types.ImportedInterfaceNode;
 /**
- * 判断输入为 ImportedInterface 节点实例
+ * 判断输入为 Interface 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
  * @description 等价于`instanceof`运算
  * @example
  * ```ts
- * if (isImportedInterface(node)) {
- *   // 在这个花括号内，node 的类型是 ImportedInterface 或者 ImportedInterface 继承类型
+ * if (isInterface(node)) {
+ *   // 在这个花括号内，node 的类型是 Interface 或者 Interface 继承类型
  * }
  * ```
  */
-export declare function isImportedInterface(node: unknown): node is Type.ImportedInterfaceNode;
+export declare function isInterface(node: unknown): node is types.InterfaceNode;
 /**
  * 判断输入为 InterfaceParam 节点实例
  *
@@ -2616,7 +2967,7 @@ export declare function isComment(node: unknown): node is Comment;
  * }
  * ```
  */
-export declare function isCallLogic(node: unknown): node is Type.CallLogicNode;
+export declare function isCallLogic(node: unknown): node is types.CallLogicNode;
 /**
  * 判断输入为 CallEvent 节点实例
  *
@@ -2655,7 +3006,7 @@ export declare function isCallFunction(node: unknown): node is CallFunction;
  * }
  * ```
  */
-export declare function isCallInterface(node: unknown): node is Type.CallInterfaceNode;
+export declare function isCallInterface(node: unknown): node is types.CallInterfaceNode;
 /**
  * 判断输入为 Destination 节点实例
  *
@@ -2825,6 +3176,19 @@ export declare function isStringLiteral(node: unknown): node is StringLiteral;
  * ```
  */
 export declare function isStringInterpolation(node: unknown): node is StringInterpolation;
+/**
+ * 判断输入为 StaticString 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，StaticString 节点没有继承类，此判断等价于`isStrictStaticString`
+ * @example
+ * ```ts
+ * if (isStaticString(node)) {
+ *   // 在这个花括号内，node 的类型是 StaticString 或者 StaticString 继承类型
+ * }
+ * ```
+ */
+export declare function isStaticString(node: unknown): node is StaticString;
 /**
  * 判断输入为 NumericLiteral 节点实例
  *
@@ -2968,6 +3332,19 @@ export declare function isNewList(node: unknown): node is NewList;
  * ```
  */
 export declare function isNewMap(node: unknown): node is NewMap;
+/**
+ * 判断输入为 Paginate 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Paginate 节点没有继承类，此判断等价于`isStrictPaginate`
+ * @example
+ * ```ts
+ * if (isPaginate(node)) {
+ *   // 在这个花括号内，node 的类型是 Paginate 或者 Paginate 继承类型
+ * }
+ * ```
+ */
+export declare function isPaginate(node: unknown): node is Paginate;
 /**
  * 判断输入为 CallQueryComponent 节点实例
  *
@@ -3151,83 +3528,83 @@ export declare function isProcessElement(node: unknown): node is ProcessElement;
  */
 export declare 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 declare function isProcessOutcome(node: unknown): node is ProcessOutcome;
+export declare function isMultiApprovalPolicy(node: unknown): node is types.MultiApprovalPolicyNode;
 /**
- * 判断输入为 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 declare function isAssignee(node: unknown): node is Assignee;
+export declare function isSequentialPolicy(node: unknown): node is 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 declare function isProcessOutcomes(node: unknown): node is ProcessOutcomes;
+export declare function isCountersignPolicy(node: unknown): node is 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 declare function isMultiApprovalPolicy(node: unknown): node is Type.MultiApprovalPolicyNode;
+export declare function isProcessOutcome(node: unknown): node is 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 declare function isSequentialPolicy(node: unknown): node is SequentialPolicy;
+export declare function isAssignee(node: unknown): node is 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 declare function isCountersignPolicy(node: unknown): node is CountersignPolicy;
+export declare function isProcessOutcomes(node: unknown): node is ProcessOutcomes;
 /**
  * 判断输入为 Role 节点实例
  *
@@ -3401,7 +3778,7 @@ export declare function isFrontendLibrary(node: unknown): node is FrontendLibrar
  * 判断输入为 ViewBlock 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ViewBlock 节点没有继承类，此判断等价于`isStrictViewBlock`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isViewBlock(node)) {
@@ -3409,7 +3786,20 @@ export declare function isFrontendLibrary(node: unknown): node is FrontendLibrar
  * }
  * ```
  */
-export declare function isViewBlock(node: unknown): node is ViewBlock;
+export declare function isViewBlock(node: unknown): node is types.ViewBlockNode;
+/**
+ * 判断输入为 ViewBlockWithImage 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ViewBlockWithImage 节点没有继承类，此判断等价于`isStrictViewBlockWithImage`
+ * @example
+ * ```ts
+ * if (isViewBlockWithImage(node)) {
+ *   // 在这个花括号内，node 的类型是 ViewBlockWithImage 或者 ViewBlockWithImage 继承类型
+ * }
+ * ```
+ */
+export declare function isViewBlockWithImage(node: unknown): node is ViewBlockWithImage;
 /**
  * 判断输入为 AuthInterface 节点实例
  *
@@ -3448,7 +3838,7 @@ export declare function isCallAuthInterface(node: unknown): node is CallAuthInte
  * }
  * ```
  */
-export declare function isTriggerEvent(node: unknown): node is Type.TriggerEventNode;
+export declare function isTriggerEvent(node: unknown): node is types.TriggerEventNode;
 /**
  * 判断输入为 MsgTriggerEvent 节点实例
  *
@@ -3487,7 +3877,7 @@ export declare function isConnectorTrigger(node: unknown): node is ConnectorTrig
  * }
  * ```
  */
-export declare function isTriggerLauncher(node: unknown): node is Type.TriggerLauncherNode;
+export declare function isTriggerLauncher(node: unknown): node is types.TriggerLauncherNode;
 /**
  * 判断输入为 MsgTriggerLauncher 节点实例
  *
@@ -3853,17 +4243,137 @@ export declare function assertStrictBindEvent(node: unknown): asserts node is Bi
  */
 export declare function assertStrictBindStyle(node: unknown): asserts node is BindStyle;
 /**
- * 严格断言为 ViewComponent 节点
+ * 严格断言为 ThemeVariable 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictThemeVariable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictThemeVariable(node: unknown): asserts node is ThemeVariable;
+/**
+ * 严格断言为 InputSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InputSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictInputSetter(node: unknown): asserts node is InputSetter;
+/**
+ * 严格断言为 SwitchSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSwitchSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictSwitchSetter(node: unknown): asserts node is SwitchSetter;
+/**
+ * 严格断言为 SetterOption 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSetterOption(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SetterOption 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictSetterOption(node: unknown): asserts node is SetterOption;
+/**
+ * 严格断言为 EnumSelectSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictEnumSelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumSelectSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictEnumSelectSetter(node: unknown): asserts node is EnumSelectSetter;
+/**
+ * 严格断言为 CapsulesSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictCapsulesSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CapsulesSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictCapsulesSetter(node: unknown): asserts node is CapsulesSetter;
+/**
+ * 严格断言为 NumberInputSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictNumberInputSetter(node: unknown): asserts node is NumberInputSetter;
+/**
+ * 严格断言为 IconSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictIconSetter(node: unknown): asserts node is IconSetter;
+/**
+ * 严格断言为 ImageSetter 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 类型
+ * assertStrictImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictViewComponent(node: unknown): asserts node is ViewComponent;
+export declare function assertStrictImageSetter(node: unknown): asserts node is ImageSetter;
+/**
+ * 严格断言为 PropertySelectSetter 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter;
+/**
+ * 严格断言为 ViewComponentDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictViewComponentDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration;
 /**
  * 严格断言为 BusinessComponent 节点
  *
@@ -3901,77 +4411,89 @@ export declare function assertStrictAttribute(node: unknown): asserts node is At
  */
 export declare function assertStrictEvent(node: unknown): asserts node is Event;
 /**
- * 严格断言为 Slot 节点
+ * 严格断言为 PropDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 类型
+ * assertStrictPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictSlot(node: unknown): asserts node is Slot;
+export declare function assertStrictPropDeclaration(node: unknown): asserts node is PropDeclaration;
 /**
- * 严格断言为 Theme 节点
+ * 严格断言为 EventDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictTheme(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 类型
+ * assertStrictEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictTheme(node: unknown): asserts node is Theme;
+export declare function assertStrictEventDeclaration(node: unknown): asserts node is EventDeclaration;
 /**
- * 严格断言为 StaticString 节点
+ * 严格断言为 SlotDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictStaticString(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 类型
+ * assertStrictSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictStaticString(node: unknown): asserts node is StaticString;
+export declare function assertStrictSlotDeclaration(node: unknown): asserts node is SlotDeclaration;
 /**
- * 严格断言为 Logic 节点
+ * 严格断言为 LogicDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 类型
+ * assertStrictLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictLogic(node: unknown): asserts node is Logic;
+export declare function assertStrictLogicDeclaration(node: unknown): asserts node is LogicDeclaration;
 /**
- * 严格断言为 AuthLogic 节点
+ * 严格断言为 Theme 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictAuthLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 类型
+ * assertStrictTheme(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic;
+export declare function assertStrictTheme(node: unknown): asserts node is Theme;
 /**
- * 严格断言为 BusinessLogic 节点
+ * 严格断言为 Logic 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
+ * assertStrictLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic;
+export declare function assertStrictLogic(node: unknown): asserts node is Logic;
+/**
+ * 严格断言为 AuthLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictAuthLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic;
 /**
  * 严格断言为 AuthLogicForCallInterface 节点
  *
@@ -3996,6 +4518,18 @@ export declare function assertStrictAuthLogicForCallInterface(node: unknown): as
  * ```
  */
 export declare function assertStrictOverriddenLogic(node: unknown): asserts node is OverriddenLogic;
+/**
+ * 严格断言为 BusinessLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic;
 /**
  * 严格断言为 Param 节点
  *
@@ -4488,6 +5022,18 @@ export declare function assertStrictStringLiteral(node: unknown): asserts node i
  * ```
  */
 export declare function assertStrictStringInterpolation(node: unknown): asserts node is StringInterpolation;
+/**
+ * 严格断言为 StaticString 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictStaticString(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictStaticString(node: unknown): asserts node is StaticString;
 /**
  * 严格断言为 NumericLiteral 节点
  *
@@ -4620,6 +5166,18 @@ export declare function assertStrictNewList(node: unknown): asserts node is NewL
  * ```
  */
 export declare function assertStrictNewMap(node: unknown): asserts node is NewMap;
+/**
+ * 严格断言为 Paginate 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictPaginate(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictPaginate(node: unknown): asserts node is Paginate;
 /**
  * 严格断言为 CallQueryComponent 节点
  *
@@ -4789,77 +5347,65 @@ export declare function assertStrictProcessElement(node: unknown): asserts node
  */
 export declare function assertStrictProcessComponent(node: unknown): asserts node is ProcessComponent;
 /**
- * 严格断言为 ProcessOutcome 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictProcessOutcome(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export declare function assertStrictProcessOutcome(node: unknown): asserts node is ProcessOutcome;
-/**
- * 严格断言为 Assignee 节点
+ * 严格断言为 SequentialPolicy 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictAssignee(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 类型
+ * assertStrictSequentialPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictAssignee(node: unknown): asserts node is Assignee;
+export declare function assertStrictSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
 /**
- * 严格断言为 ProcessOutcomes 节点
+ * 严格断言为 CountersignPolicy 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictProcessOutcomes(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 类型
+ * assertStrictCountersignPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
+export declare function assertStrictCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
 /**
- * 严格断言为 MultiApprovalPolicy 节点
+ * 严格断言为 ProcessOutcome 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictMultiApprovalPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 类型
+ * assertStrictProcessOutcome(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictMultiApprovalPolicy(node: unknown): asserts node is MultiApprovalPolicy;
+export declare function assertStrictProcessOutcome(node: unknown): asserts node is ProcessOutcome;
 /**
- * 严格断言为 SequentialPolicy 节点
+ * 严格断言为 Assignee 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSequentialPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 类型
+ * assertStrictAssignee(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
+export declare function assertStrictAssignee(node: unknown): asserts node is Assignee;
 /**
- * 严格断言为 CountersignPolicy 节点
+ * 严格断言为 ProcessOutcomes 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictCountersignPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 类型
+ * assertStrictProcessOutcomes(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
+export declare function assertStrictProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
 /**
  * 严格断言为 Role 节点
  *
@@ -5028,6 +5574,18 @@ export declare function assertStrictFrontendLibrary(node: unknown): asserts node
  * ```
  */
 export declare function assertStrictViewBlock(node: unknown): asserts node is ViewBlock;
+/**
+ * 严格断言为 ViewBlockWithImage 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictViewBlockWithImage(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlockWithImage 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictViewBlockWithImage(node: unknown): asserts node is ViewBlockWithImage;
 /**
  * 严格断言为 AuthInterface 节点
  *
@@ -5173,7 +5731,7 @@ export declare function assertApp(node: unknown): asserts node is App;
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertModule(node: unknown): asserts node is Type.ModuleNode;
+export declare function assertModule(node: unknown): asserts node is types.ModuleNode;
 /**
  * 断言为 Namespace 节点
  *
@@ -5487,18 +6045,161 @@ export declare function assertBindEvent(node: unknown): asserts node is BindEven
  */
 export declare function assertBindStyle(node: unknown): asserts node is BindStyle;
 /**
- * 断言为 ViewComponent 节点
+ * 断言为 ThemeVariable 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictThemeVariable`方法
+ * @example
+ * ```ts
+ * assertThemeVariable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 或者 ThemeVariable 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertThemeVariable(node: unknown): asserts node is ThemeVariable;
+/**
+ * 断言为 BaseSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBaseSetter`方法
+ * @example
+ * ```ts
+ * assertBaseSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BaseSetter 或者 BaseSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertBaseSetter(node: unknown): asserts node is types.BaseSetterNode;
+/**
+ * 断言为 InputSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictInputSetter`方法
+ * @example
+ * ```ts
+ * assertInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InputSetter 或者 InputSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertInputSetter(node: unknown): asserts node is InputSetter;
+/**
+ * 断言为 SwitchSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSwitchSetter`方法
+ * @example
+ * ```ts
+ * assertSwitchSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchSetter 或者 SwitchSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertSwitchSetter(node: unknown): asserts node is SwitchSetter;
+/**
+ * 断言为 SetterOption 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSetterOption`方法
+ * @example
+ * ```ts
+ * assertSetterOption(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SetterOption 或者 SetterOption 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertSetterOption(node: unknown): asserts node is SetterOption;
+/**
+ * 断言为 EnumSelectSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictEnumSelectSetter`方法
+ * @example
+ * ```ts
+ * assertEnumSelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumSelectSetter 或者 EnumSelectSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertEnumSelectSetter(node: unknown): asserts node is EnumSelectSetter;
+/**
+ * 断言为 CapsulesSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictCapsulesSetter`方法
+ * @example
+ * ```ts
+ * assertCapsulesSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CapsulesSetter 或者 CapsulesSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertCapsulesSetter(node: unknown): asserts node is CapsulesSetter;
+/**
+ * 断言为 NumberInputSetter 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictViewComponent`方法
+ * @description 节点没有继承类时，等价于`assertStrictNumberInputSetter`方法
  * @example
  * ```ts
- * assertViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 或者 ViewComponent 继承类型
+ * assertNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 或者 NumberInputSetter 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertViewComponent(node: unknown): asserts node is ViewComponent;
+export declare function assertNumberInputSetter(node: unknown): asserts node is NumberInputSetter;
+/**
+ * 断言为 IconSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictIconSetter`方法
+ * @example
+ * ```ts
+ * assertIconSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IconSetter 或者 IconSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertIconSetter(node: unknown): asserts node is IconSetter;
+/**
+ * 断言为 ImageSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictImageSetter`方法
+ * @example
+ * ```ts
+ * assertImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 或者 ImageSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertImageSetter(node: unknown): asserts node is ImageSetter;
+/**
+ * 断言为 PropertySelectSetter 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPropertySelectSetter`方法
+ * @example
+ * ```ts
+ * assertPropertySelectSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertySelectSetter 或者 PropertySelectSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertPropertySelectSetter(node: unknown): asserts node is PropertySelectSetter;
+/**
+ * 断言为 ViewComponentDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictViewComponentDeclaration`方法
+ * @example
+ * ```ts
+ * assertViewComponentDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration;
 /**
  * 断言为 BusinessComponent 节点
  *
@@ -5539,83 +6240,96 @@ export declare function assertAttribute(node: unknown): asserts node is Attribut
  */
 export declare 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 declare function assertSlot(node: unknown): asserts node is Slot;
+export declare function assertPropDeclaration(node: unknown): asserts node is PropDeclaration;
 /**
- * 断言为 Theme 节点
+ * 断言为 EventDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictTheme`方法
+ * @description 节点没有继承类时，等价于`assertStrictEventDeclaration`方法
  * @example
  * ```ts
- * assertTheme(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 或者 Theme 继承类型
+ * assertEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 或者 EventDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertTheme(node: unknown): asserts node is Theme;
+export declare function assertEventDeclaration(node: unknown): asserts node is EventDeclaration;
 /**
- * 断言为 StaticString 节点
+ * 断言为 SlotDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictStaticString`方法
+ * @description 节点没有继承类时，等价于`assertStrictSlotDeclaration`方法
  * @example
  * ```ts
- * assertStaticString(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 或者 StaticString 继承类型
+ * assertSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 或者 SlotDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStaticString(node: unknown): asserts node is StaticString;
+export declare function assertSlotDeclaration(node: unknown): asserts node is SlotDeclaration;
 /**
- * 断言为 Logic 节点
+ * 断言为 LogicDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictLogic`方法
+ * @description 节点没有继承类时，等价于`assertStrictLogicDeclaration`方法
  * @example
  * ```ts
- * assertLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 或者 Logic 继承类型
+ * assertLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 或者 LogicDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertLogic(node: unknown): asserts node is Type.LogicNode;
+export declare function assertLogicDeclaration(node: unknown): asserts node is LogicDeclaration;
 /**
- * 断言为 AuthLogic 节点
+ * 断言为 Theme 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictAuthLogic`方法
+ * @description 节点没有继承类时，等价于`assertStrictTheme`方法
  * @example
  * ```ts
- * assertAuthLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 或者 AuthLogic 继承类型
+ * assertTheme(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 或者 Theme 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertAuthLogic(node: unknown): asserts node is Type.AuthLogicNode;
+export declare function assertTheme(node: unknown): asserts node is Theme;
 /**
- * 断言为 BusinessLogic 节点
+ * 断言为 Logic 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
+ * @description 节点没有继承类时，等价于`assertStrictLogic`方法
  * @example
  * ```ts
- * assertBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
+ * assertLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 或者 Logic 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertBusinessLogic(node: unknown): asserts node is BusinessLogic;
+export declare function assertLogic(node: unknown): asserts node is types.LogicNode;
+/**
+ * 断言为 AuthLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAuthLogic`方法
+ * @example
+ * ```ts
+ * assertAuthLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 或者 AuthLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertAuthLogic(node: unknown): asserts node is types.AuthLogicNode;
 /**
  * 断言为 AuthLogicForCallInterface 节点
  *
@@ -5642,6 +6356,19 @@ export declare function assertAuthLogicForCallInterface(node: unknown): asserts
  * ```
  */
 export declare function assertOverriddenLogic(node: unknown): asserts node is OverriddenLogic;
+/**
+ * 断言为 BusinessLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
+ * @example
+ * ```ts
+ * assertBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertBusinessLogic(node: unknown): asserts node is BusinessLogic;
 /**
  * 断言为 AbstractInterface 节点
  *
@@ -5654,7 +6381,7 @@ export declare function assertOverriddenLogic(node: unknown): asserts node is Ov
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertAbstractInterface(node: unknown): asserts node is Type.AbstractInterfaceNode;
+export declare function assertAbstractInterface(node: unknown): asserts node is types.AbstractInterfaceNode;
 /**
  * 断言为 Param 节点
  *
@@ -5667,7 +6394,7 @@ export declare function assertAbstractInterface(node: unknown): asserts node is
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertParam(node: unknown): asserts node is Type.ParamNode;
+export declare function assertParam(node: unknown): asserts node is types.ParamNode;
 /**
  * 断言为 ParamWithGroup 节点
  *
@@ -5706,7 +6433,7 @@ export declare function assertReturn(node: unknown): asserts node is Return;
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertVariable(node: unknown): asserts node is Type.VariableNode;
+export declare function assertVariable(node: unknown): asserts node is types.VariableNode;
 /**
  * 断言为 BackendVariable 节点
  *
@@ -5758,7 +6485,7 @@ export declare function assertConstant(node: unknown): asserts node is Constant;
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertLogicItem(node: unknown): asserts node is Type.LogicItemNode;
+export declare function assertLogicItem(node: unknown): asserts node is types.LogicItemNode;
 /**
  * 断言为 Function 节点
  *
@@ -5786,31 +6513,31 @@ export declare function assertFunction(node: unknown): asserts node is Function;
  */
 export declare function assertAnonymousFunction(node: unknown): asserts node is AnonymousFunction;
 /**
- * 断言为 Interface 节点
+ * 断言为 ImportedInterface 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictInterface`方法
+ * @description 节点没有继承类时，等价于`assertStrictImportedInterface`方法
  * @example
  * ```ts
- * assertInterface(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 或者 Interface 继承类型
+ * assertImportedInterface(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImportedInterface 或者 ImportedInterface 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertInterface(node: unknown): asserts node is Type.InterfaceNode;
+export declare function assertImportedInterface(node: unknown): asserts node is types.ImportedInterfaceNode;
 /**
- * 断言为 ImportedInterface 节点
+ * 断言为 Interface 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictImportedInterface`方法
+ * @description 节点没有继承类时，等价于`assertStrictInterface`方法
  * @example
  * ```ts
- * assertImportedInterface(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImportedInterface 或者 ImportedInterface 继承类型
+ * assertInterface(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 或者 Interface 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertImportedInterface(node: unknown): asserts node is Type.ImportedInterfaceNode;
+export declare function assertInterface(node: unknown): asserts node is types.InterfaceNode;
 /**
  * 断言为 InterfaceParam 节点
  *
@@ -6005,7 +6732,7 @@ export declare function assertComment(node: unknown): asserts node is Comment;
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertCallLogic(node: unknown): asserts node is Type.CallLogicNode;
+export declare function assertCallLogic(node: unknown): asserts node is types.CallLogicNode;
 /**
  * 断言为 CallEvent 节点
  *
@@ -6044,7 +6771,7 @@ export declare function assertCallFunction(node: unknown): asserts node is CallF
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertCallInterface(node: unknown): asserts node is Type.CallInterfaceNode;
+export declare function assertCallInterface(node: unknown): asserts node is types.CallInterfaceNode;
 /**
  * 断言为 Destination 节点
  *
@@ -6214,6 +6941,19 @@ export declare function assertStringLiteral(node: unknown): asserts node is Stri
  * ```
  */
 export declare function assertStringInterpolation(node: unknown): asserts node is StringInterpolation;
+/**
+ * 断言为 StaticString 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictStaticString`方法
+ * @example
+ * ```ts
+ * assertStaticString(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StaticString 或者 StaticString 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStaticString(node: unknown): asserts node is StaticString;
 /**
  * 断言为 NumericLiteral 节点
  *
@@ -6357,6 +7097,19 @@ export declare function assertNewList(node: unknown): asserts node is NewList;
  * ```
  */
 export declare function assertNewMap(node: unknown): asserts node is NewMap;
+/**
+ * 断言为 Paginate 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPaginate`方法
+ * @example
+ * ```ts
+ * assertPaginate(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 或者 Paginate 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertPaginate(node: unknown): asserts node is Paginate;
 /**
  * 断言为 CallQueryComponent 节点
  *
@@ -6540,83 +7293,83 @@ export declare function assertProcessElement(node: unknown): asserts node is Pro
  */
 export declare function assertProcessComponent(node: unknown): asserts node is ProcessComponent;
 /**
- * 断言为 ProcessOutcome 节点
+ * 断言为 MultiApprovalPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictProcessOutcome`方法
+ * @description 节点没有继承类时，等价于`assertStrictMultiApprovalPolicy`方法
  * @example
  * ```ts
- * assertProcessOutcome(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 或者 ProcessOutcome 继承类型
+ * assertMultiApprovalPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertProcessOutcome(node: unknown): asserts node is ProcessOutcome;
+export declare function assertMultiApprovalPolicy(node: unknown): asserts node is types.MultiApprovalPolicyNode;
 /**
- * 断言为 Assignee 节点
+ * 断言为 SequentialPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictAssignee`方法
+ * @description 节点没有继承类时，等价于`assertStrictSequentialPolicy`方法
  * @example
  * ```ts
- * assertAssignee(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 或者 Assignee 继承类型
+ * assertSequentialPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 或者 SequentialPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertAssignee(node: unknown): asserts node is Assignee;
+export declare function assertSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
 /**
- * 断言为 ProcessOutcomes 节点
+ * 断言为 CountersignPolicy 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictProcessOutcomes`方法
+ * @description 节点没有继承类时，等价于`assertStrictCountersignPolicy`方法
  * @example
  * ```ts
- * assertProcessOutcomes(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 或者 ProcessOutcomes 继承类型
+ * assertCountersignPolicy(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 或者 CountersignPolicy 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
+export declare function assertCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
 /**
- * 断言为 MultiApprovalPolicy 节点
+ * 断言为 ProcessOutcome 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictMultiApprovalPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictProcessOutcome`方法
  * @example
  * ```ts
- * assertMultiApprovalPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
+ * assertProcessOutcome(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 或者 ProcessOutcome 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertMultiApprovalPolicy(node: unknown): asserts node is Type.MultiApprovalPolicyNode;
+export declare function assertProcessOutcome(node: unknown): asserts node is ProcessOutcome;
 /**
- * 断言为 SequentialPolicy 节点
+ * 断言为 Assignee 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictSequentialPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictAssignee`方法
  * @example
  * ```ts
- * assertSequentialPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 或者 SequentialPolicy 继承类型
+ * assertAssignee(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 或者 Assignee 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
+export declare function assertAssignee(node: unknown): asserts node is Assignee;
 /**
- * 断言为 CountersignPolicy 节点
+ * 断言为 ProcessOutcomes 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictCountersignPolicy`方法
+ * @description 节点没有继承类时，等价于`assertStrictProcessOutcomes`方法
  * @example
  * ```ts
- * assertCountersignPolicy(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 或者 CountersignPolicy 继承类型
+ * assertProcessOutcomes(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 或者 ProcessOutcomes 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
+export declare function assertProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
 /**
  * 断言为 Role 节点
  *
@@ -6798,7 +7551,20 @@ export declare function assertFrontendLibrary(node: unknown): asserts node is Fr
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertViewBlock(node: unknown): asserts node is ViewBlock;
+export declare function assertViewBlock(node: unknown): asserts node is types.ViewBlockNode;
+/**
+ * 断言为 ViewBlockWithImage 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictViewBlockWithImage`方法
+ * @example
+ * ```ts
+ * assertViewBlockWithImage(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlockWithImage 或者 ViewBlockWithImage 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertViewBlockWithImage(node: unknown): asserts node is ViewBlockWithImage;
 /**
  * 断言为 AuthInterface 节点
  *
@@ -6837,7 +7603,7 @@ export declare function assertCallAuthInterface(node: unknown): asserts node is
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertTriggerEvent(node: unknown): asserts node is Type.TriggerEventNode;
+export declare function assertTriggerEvent(node: unknown): asserts node is types.TriggerEventNode;
 /**
  * 断言为 MsgTriggerEvent 节点
  *
@@ -6876,7 +7642,7 @@ export declare function assertConnectorTrigger(node: unknown): asserts node is C
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertTriggerLauncher(node: unknown): asserts node is Type.TriggerLauncherNode;
+export declare function assertTriggerLauncher(node: unknown): asserts node is types.TriggerLauncherNode;
 /**
  * 断言为 MsgTriggerLauncher 节点
  *