@lcap/nasl 3.5.0-beta.1 → 3.5.0-beta.2

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

@@ -1,6 +1,7 @@
 import type { App } from '../App__';
 import type { Module } from '../Module__';
 import type { Namespace } from '../Namespace__';
+import type { FrontendType } from '../FrontendType__';
 import type { Frontend } from '../Frontend__';
 import type { Backend } from '../Backend__';
 import type { Integration } from '../Integration__';
@@ -24,6 +25,7 @@ import type { BindDirective } from '../BindDirective__';
 import type { BindEvent } from '../BindEvent__';
 import type { BindStyle } from '../BindStyle__';
 import type { ViewComponent } from '../ViewComponent__';
+import type { BusinessComponent } from '../BusinessComponent__';
 import type { Attribute } from '../Attribute__';
 import type { Event } from '../Event__';
 import type { Slot } from '../Slot__';
@@ -31,9 +33,11 @@ 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 { Param } from '../Param__';
+import type { ParamWithGroup } from '../ParamWithGroup__';
 import type { Return } from '../Return__';
 import type { Variable } from '../Variable__';
 import type { BackendVariable } from '../BackendVariable__';
@@ -57,6 +61,7 @@ import type { Assignment } from '../Assignment__';
 import type { BatchAssignment } from '../BatchAssignment__';
 import type { Comment } from '../Comment__';
 import type { CallLogic } from '../CallLogic__';
+import type { CallEvent } from '../CallEvent__';
 import type { CallFunction } from '../CallFunction__';
 import type { CallInterface } from '../CallInterface__';
 import type { Destination } from '../Destination__';
@@ -83,7 +88,6 @@ 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__';
@@ -183,6 +187,18 @@ export declare function isStrictModule(node: unknown): node is Module;
  * ```
  */
 export declare function isStrictNamespace(node: unknown): node is Namespace;
+/**
+ * 严格判断输入为 FrontendType 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictFrontendType(node)) {
+ *   // 在这个花括号内，node 的类型为 FrontendType
+ * }
+ * ```
+ */
+export declare function isStrictFrontendType(node: unknown): node is FrontendType;
 /**
  * 严格判断输入为 Frontend 节点
  *
@@ -459,6 +475,18 @@ export declare function isStrictBindStyle(node: unknown): node is BindStyle;
  * ```
  */
 export declare function isStrictViewComponent(node: unknown): node is ViewComponent;
+/**
+ * 严格判断输入为 BusinessComponent 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessComponent
+ * }
+ * ```
+ */
+export declare function isStrictBusinessComponent(node: unknown): node is BusinessComponent;
 /**
  * 严格判断输入为 Attribute 节点
  *
@@ -543,6 +571,18 @@ export declare function isStrictLogic(node: unknown): node is Logic;
  * ```
  */
 export declare function isStrictAuthLogic(node: unknown): node is AuthLogic;
+/**
+ * 严格判断输入为 BusinessLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 BusinessLogic
+ * }
+ * ```
+ */
+export declare function isStrictBusinessLogic(node: unknown): node is BusinessLogic;
 /**
  * 严格判断输入为 AuthLogicForCallInterface 节点
  *
@@ -579,6 +619,18 @@ export declare function isStrictOverriddenLogic(node: unknown): node is Overridd
  * ```
  */
 export declare function isStrictParam(node: unknown): node is Param;
+/**
+ * 严格判断输入为 ParamWithGroup 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictParamWithGroup(node)) {
+ *   // 在这个花括号内，node 的类型为 ParamWithGroup
+ * }
+ * ```
+ */
+export declare function isStrictParamWithGroup(node: unknown): node is ParamWithGroup;
 /**
  * 严格判断输入为 Return 节点
  *
@@ -855,6 +907,18 @@ export declare function isStrictComment(node: unknown): node is Comment;
  * ```
  */
 export declare function isStrictCallLogic(node: unknown): node is CallLogic;
+/**
+ * 严格判断输入为 CallEvent 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictCallEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 CallEvent
+ * }
+ * ```
+ */
+export declare function isStrictCallEvent(node: unknown): node is CallEvent;
 /**
  * 严格判断输入为 CallFunction 节点
  *
@@ -1167,18 +1231,6 @@ 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 节点
  *
@@ -1746,6 +1798,19 @@ export declare function isModule(node: unknown): node is Type.ModuleNode;
  * ```
  */
 export declare function isNamespace(node: unknown): node is Namespace;
+/**
+ * 判断输入为 FrontendType 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，FrontendType 节点没有继承类，此判断等价于`isStrictFrontendType`
+ * @example
+ * ```ts
+ * if (isFrontendType(node)) {
+ *   // 在这个花括号内，node 的类型是 FrontendType 或者 FrontendType 继承类型
+ * }
+ * ```
+ */
+export declare function isFrontendType(node: unknown): node is FrontendType;
 /**
  * 判断输入为 Frontend 节点实例
  *
@@ -2045,6 +2110,19 @@ export declare function isBindStyle(node: unknown): node is BindStyle;
  * ```
  */
 export declare function isViewComponent(node: unknown): node is ViewComponent;
+/**
+ * 判断输入为 BusinessComponent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
+ * @example
+ * ```ts
+ * if (isBusinessComponent(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
+ * }
+ * ```
+ */
+export declare function isBusinessComponent(node: unknown): node is BusinessComponent;
 /**
  * 判断输入为 Attribute 节点实例
  *
@@ -2136,6 +2214,19 @@ export declare function isLogic(node: unknown): node is Type.LogicNode;
  * ```
  */
 export declare function isAuthLogic(node: unknown): node is Type.AuthLogicNode;
+/**
+ * 判断输入为 BusinessLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
+ * @example
+ * ```ts
+ * if (isBusinessLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
+ * }
+ * ```
+ */
+export declare function isBusinessLogic(node: unknown): node is BusinessLogic;
 /**
  * 判断输入为 AuthLogicForCallInterface 节点实例
  *
@@ -2179,7 +2270,7 @@ export declare function isAbstractInterface(node: unknown): node is Type.Abstrac
  * 判断输入为 Param 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Param 节点没有继承类，此判断等价于`isStrictParam`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isParam(node)) {
@@ -2187,7 +2278,20 @@ export declare function isAbstractInterface(node: unknown): node is Type.Abstrac
  * }
  * ```
  */
-export declare function isParam(node: unknown): node is Param;
+export declare function isParam(node: unknown): node is Type.ParamNode;
+/**
+ * 判断输入为 ParamWithGroup 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ParamWithGroup 节点没有继承类，此判断等价于`isStrictParamWithGroup`
+ * @example
+ * ```ts
+ * if (isParamWithGroup(node)) {
+ *   // 在这个花括号内，node 的类型是 ParamWithGroup 或者 ParamWithGroup 继承类型
+ * }
+ * ```
+ */
+export declare function isParamWithGroup(node: unknown): node is ParamWithGroup;
 /**
  * 判断输入为 Return 节点实例
  *
@@ -2513,6 +2617,19 @@ export declare function isComment(node: unknown): node is Comment;
  * ```
  */
 export declare function isCallLogic(node: unknown): node is Type.CallLogicNode;
+/**
+ * 判断输入为 CallEvent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，CallEvent 节点没有继承类，此判断等价于`isStrictCallEvent`
+ * @example
+ * ```ts
+ * if (isCallEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 CallEvent 或者 CallEvent 继承类型
+ * }
+ * ```
+ */
+export declare function isCallEvent(node: unknown): node is CallEvent;
 /**
  * 判断输入为 CallFunction 节点实例
  *
@@ -2851,19 +2968,6 @@ 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 节点实例
  *
@@ -3472,6 +3576,18 @@ export declare function assertStrictModule(node: unknown): asserts node is Modul
  * ```
  */
 export declare function assertStrictNamespace(node: unknown): asserts node is Namespace;
+/**
+ * 严格断言为 FrontendType 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictFrontendType(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictFrontendType(node: unknown): asserts node is FrontendType;
 /**
  * 严格断言为 Frontend 节点
  *
@@ -3748,6 +3864,18 @@ export declare function assertStrictBindStyle(node: unknown): asserts node is Bi
  * ```
  */
 export declare function assertStrictViewComponent(node: unknown): asserts node is ViewComponent;
+/**
+ * 严格断言为 BusinessComponent 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessComponent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictBusinessComponent(node: unknown): asserts node is BusinessComponent;
 /**
  * 严格断言为 Attribute 节点
  *
@@ -3832,6 +3960,18 @@ export declare function assertStrictLogic(node: unknown): asserts node is Logic;
  * ```
  */
 export declare function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic;
+/**
+ * 严格断言为 BusinessLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic;
 /**
  * 严格断言为 AuthLogicForCallInterface 节点
  *
@@ -3868,6 +4008,18 @@ export declare function assertStrictOverriddenLogic(node: unknown): asserts node
  * ```
  */
 export declare function assertStrictParam(node: unknown): asserts node is Param;
+/**
+ * 严格断言为 ParamWithGroup 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictParamWithGroup(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictParamWithGroup(node: unknown): asserts node is ParamWithGroup;
 /**
  * 严格断言为 Return 节点
  *
@@ -4144,6 +4296,18 @@ export declare function assertStrictComment(node: unknown): asserts node is Comm
  * ```
  */
 export declare function assertStrictCallLogic(node: unknown): asserts node is CallLogic;
+/**
+ * 严格断言为 CallEvent 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictCallEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictCallEvent(node: unknown): asserts node is CallEvent;
 /**
  * 严格断言为 CallFunction 节点
  *
@@ -4456,18 +4620,6 @@ 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 节点
  *
@@ -5035,6 +5187,19 @@ export declare function assertModule(node: unknown): asserts node is Type.Module
  * ```
  */
 export declare function assertNamespace(node: unknown): asserts node is Namespace;
+/**
+ * 断言为 FrontendType 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictFrontendType`方法
+ * @example
+ * ```ts
+ * assertFrontendType(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 或者 FrontendType 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertFrontendType(node: unknown): asserts node is FrontendType;
 /**
  * 断言为 Frontend 节点
  *
@@ -5334,6 +5499,19 @@ export declare function assertBindStyle(node: unknown): asserts node is BindStyl
  * ```
  */
 export declare function assertViewComponent(node: unknown): asserts node is ViewComponent;
+/**
+ * 断言为 BusinessComponent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessComponent`方法
+ * @example
+ * ```ts
+ * assertBusinessComponent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 或者 BusinessComponent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertBusinessComponent(node: unknown): asserts node is BusinessComponent;
 /**
  * 断言为 Attribute 节点
  *
@@ -5425,6 +5603,19 @@ export declare function assertLogic(node: unknown): asserts node is Type.LogicNo
  * ```
  */
 export declare function assertAuthLogic(node: unknown): asserts node is Type.AuthLogicNode;
+/**
+ * 断言为 BusinessLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
+ * @example
+ * ```ts
+ * assertBusinessLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertBusinessLogic(node: unknown): asserts node is BusinessLogic;
 /**
  * 断言为 AuthLogicForCallInterface 节点
  *
@@ -5476,7 +5667,20 @@ export declare function assertAbstractInterface(node: unknown): asserts node is
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export declare function assertParam(node: unknown): asserts node is Param;
+export declare function assertParam(node: unknown): asserts node is Type.ParamNode;
+/**
+ * 断言为 ParamWithGroup 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictParamWithGroup`方法
+ * @example
+ * ```ts
+ * assertParamWithGroup(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 或者 ParamWithGroup 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertParamWithGroup(node: unknown): asserts node is ParamWithGroup;
 /**
  * 断言为 Return 节点
  *
@@ -5802,6 +6006,19 @@ export declare function assertComment(node: unknown): asserts node is Comment;
  * ```
  */
 export declare function assertCallLogic(node: unknown): asserts node is Type.CallLogicNode;
+/**
+ * 断言为 CallEvent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictCallEvent`方法
+ * @example
+ * ```ts
+ * assertCallEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 或者 CallEvent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertCallEvent(node: unknown): asserts node is CallEvent;
 /**
  * 断言为 CallFunction 节点
  *
@@ -6140,19 +6357,6 @@ 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 节点
  *