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

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

@@ -24,11 +24,24 @@ 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 { Logic } from '../Logic__';
 import type { AuthLogic } from '../AuthLogic__';
@@ -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__';
@@ -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 (isStrictViewComponent(node)) {
- *   // 在这个花括号内，node 的类型为 ViewComponent
+ * if (isStrictThemeVariable(node)) {
+ *   // 在这个花括号内，node 的类型为 ThemeVariable
  * }
  * ```
  */
-export declare function isStrictViewComponent(node: unknown): node is ViewComponent;
+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 (isStrictIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型为 IconSetter
+ * }
+ * ```
+ */
+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,17 +646,53 @@ export declare function isStrictAttribute(node: unknown): node is Attribute;
  */
 export declare function isStrictEvent(node: unknown): node is Event;
 /**
- * 严格判断输入为 Slot 节点
+ * 严格判断输入为 PropDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictPropDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 PropDeclaration
+ * }
+ * ```
+ */
+export declare function isStrictPropDeclaration(node: unknown): node is PropDeclaration;
+/**
+ * 严格判断输入为 EventDeclaration 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictSlot(node)) {
- *   // 在这个花括号内，node 的类型为 Slot
+ * if (isStrictEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 EventDeclaration
  * }
  * ```
  */
-export declare function isStrictSlot(node: unknown): node is Slot;
+export declare function isStrictEventDeclaration(node: unknown): node is EventDeclaration;
+/**
+ * 严格判断输入为 SlotDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSlotDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 SlotDeclaration
+ * }
+ * ```
+ */
+export declare function isStrictSlotDeclaration(node: unknown): node is SlotDeclaration;
+/**
+ * 严格判断输入为 LogicDeclaration 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictLogicDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型为 LogicDeclaration
+ * }
+ * ```
+ */
+export declare function isStrictLogicDeclaration(node: unknown): node is LogicDeclaration;
 /**
  * 严格判断输入为 Theme 节点
  *
@@ -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 节点
  *
@@ -2098,18 +2280,161 @@ 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;
+/**
+ * 判断输入为 BaseSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isBaseSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 BaseSetter 或者 BaseSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isBaseSetter(node: unknown): node is types.BaseSetterNode;
+/**
+ * 判断输入为 InputSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，InputSetter 节点没有继承类，此判断等价于`isStrictInputSetter`
+ * @example
+ * ```ts
+ * if (isInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 InputSetter 或者 InputSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isInputSetter(node: unknown): node is InputSetter;
+/**
+ * 判断输入为 SwitchSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SwitchSetter 节点没有继承类，此判断等价于`isStrictSwitchSetter`
+ * @example
+ * ```ts
+ * if (isSwitchSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 SwitchSetter 或者 SwitchSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isSwitchSetter(node: unknown): node is SwitchSetter;
+/**
+ * 判断输入为 SetterOption 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SetterOption 节点没有继承类，此判断等价于`isStrictSetterOption`
+ * @example
+ * ```ts
+ * if (isSetterOption(node)) {
+ *   // 在这个花括号内，node 的类型是 SetterOption 或者 SetterOption 继承类型
+ * }
+ * ```
+ */
+export declare function isSetterOption(node: unknown): node is SetterOption;
+/**
+ * 判断输入为 EnumSelectSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，EnumSelectSetter 节点没有继承类，此判断等价于`isStrictEnumSelectSetter`
+ * @example
+ * ```ts
+ * if (isEnumSelectSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 EnumSelectSetter 或者 EnumSelectSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isEnumSelectSetter(node: unknown): node is EnumSelectSetter;
+/**
+ * 判断输入为 CapsulesSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，CapsulesSetter 节点没有继承类，此判断等价于`isStrictCapsulesSetter`
+ * @example
+ * ```ts
+ * if (isCapsulesSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 CapsulesSetter 或者 CapsulesSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isCapsulesSetter(node: unknown): node is CapsulesSetter;
+/**
+ * 判断输入为 NumberInputSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，NumberInputSetter 节点没有继承类，此判断等价于`isStrictNumberInputSetter`
+ * @example
+ * ```ts
+ * if (isNumberInputSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 NumberInputSetter 或者 NumberInputSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isNumberInputSetter(node: unknown): node is NumberInputSetter;
+/**
+ * 判断输入为 IconSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，IconSetter 节点没有继承类，此判断等价于`isStrictIconSetter`
+ * @example
+ * ```ts
+ * if (isIconSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 IconSetter 或者 IconSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isIconSetter(node: unknown): node is IconSetter;
+/**
+ * 判断输入为 ImageSetter 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ImageSetter 节点没有继承类，此判断等价于`isStrictImageSetter`
+ * @example
+ * ```ts
+ * if (isImageSetter(node)) {
+ *   // 在这个花括号内，node 的类型是 ImageSetter 或者 ImageSetter 继承类型
+ * }
+ * ```
+ */
+export declare function isImageSetter(node: unknown): node is ImageSetter;
+/**
+ * 判断输入为 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 节点实例
  *
@@ -2150,18 +2475,57 @@ export declare function isAttribute(node: unknown): node is Attribute;
  */
 export declare function isEvent(node: unknown): node is Event;
 /**
- * 判断输入为 Slot 节点实例
+ * 判断输入为 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`运算，Slot 节点没有继承类，此判断等价于`isStrictSlot`
+ * @description 等价于`instanceof`运算，EventDeclaration 节点没有继承类，此判断等价于`isStrictEventDeclaration`
  * @example
  * ```ts
- * if (isSlot(node)) {
- *   // 在这个花括号内，node 的类型是 Slot 或者 Slot 继承类型
+ * if (isEventDeclaration(node)) {
+ *   // 在这个花括号内，node 的类型是 EventDeclaration 或者 EventDeclaration 继承类型
  * }
  * ```
  */
-export declare function isSlot(node: unknown): node is Slot;
+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 节点实例
  *
@@ -3414,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)) {
@@ -3422,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 节点实例
  *
@@ -3866,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
- * assertStrictViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 类型
+ * assertStrictSwitchSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchSetter 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictViewComponent(node: unknown): asserts node is ViewComponent;
+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
+ * assertStrictImageSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImageSetter 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+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 节点
  *
@@ -3914,17 +4411,53 @@ 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
+ * assertStrictPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictPropDeclaration(node: unknown): asserts node is PropDeclaration;
+/**
+ * 严格断言为 EventDeclaration 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 类型
+ * assertStrictEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertStrictSlot(node: unknown): asserts node is Slot;
+export declare function assertStrictEventDeclaration(node: unknown): asserts node is EventDeclaration;
+/**
+ * 严格断言为 SlotDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictSlotDeclaration(node: unknown): asserts node is SlotDeclaration;
+/**
+ * 严格断言为 LogicDeclaration 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictLogicDeclaration(node: unknown): asserts node is LogicDeclaration;
 /**
  * 严格断言为 Theme 节点
  *
@@ -5041,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 节点
  *
@@ -5500,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 节点没有继承类时，等价于`assertStrictViewComponent`方法
+ * @description 节点没有继承类时，等价于`assertStrictThemeVariable`方法
  * @example
  * ```ts
- * assertViewComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 或者 ViewComponent 继承类型
+ * assertThemeVariable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 或者 ThemeVariable 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertViewComponent(node: unknown): asserts node is ViewComponent;
+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 节点没有继承类时，等价于`assertStrictNumberInputSetter`方法
+ * @example
+ * ```ts
+ * assertNumberInputSetter(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumberInputSetter 或者 NumberInputSetter 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+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 节点
  *
@@ -5552,18 +6240,57 @@ export declare function assertAttribute(node: unknown): asserts node is Attribut
  */
 export declare function assertEvent(node: unknown): asserts node is Event;
 /**
- * 断言为 Slot 节点
+ * 断言为 PropDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictPropDeclaration`方法
+ * @example
+ * ```ts
+ * assertPropDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 或者 PropDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertPropDeclaration(node: unknown): asserts node is PropDeclaration;
+/**
+ * 断言为 EventDeclaration 节点
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictSlot`方法
+ * @description 节点没有继承类时，等价于`assertStrictEventDeclaration`方法
  * @example
  * ```ts
- * assertSlot(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 或者 Slot 继承类型
+ * assertEventDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 或者 EventDeclaration 继承类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertSlot(node: unknown): asserts node is Slot;
+export declare function assertEventDeclaration(node: unknown): asserts node is EventDeclaration;
+/**
+ * 断言为 SlotDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSlotDeclaration`方法
+ * @example
+ * ```ts
+ * assertSlotDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SlotDeclaration 或者 SlotDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertSlotDeclaration(node: unknown): asserts node is SlotDeclaration;
+/**
+ * 断言为 LogicDeclaration 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictLogicDeclaration`方法
+ * @example
+ * ```ts
+ * assertLogicDeclaration(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicDeclaration 或者 LogicDeclaration 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertLogicDeclaration(node: unknown): asserts node is LogicDeclaration;
 /**
  * 断言为 Theme 节点
  *
@@ -6824,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 节点
  *