@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

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

@@ -1,3 +1,6 @@
+import type { Annotation } from '../Annotation__';
+import type { AnnotationProperty } from '../AnnotationProperty__';
+import type { ApplyAnnotation } from '../ApplyAnnotation__';
 import type { App } from '../App__';
 import type { Module } from '../Module__';
 import type { Namespace } from '../Namespace__';
@@ -55,6 +58,7 @@ import type { Variable } from '../Variable__';
 import type { BackendVariable } from '../BackendVariable__';
 import type { FrontendVariable } from '../FrontendVariable__';
 import type { Constant } from '../Constant__';
+import type { SubLogic } from '../SubLogic__';
 import type { Function } from '../Function__';
 import type { AnonymousFunction } from '../AnonymousFunction__';
 import type { Interface } from '../Interface__';
@@ -155,6 +159,9 @@ import type { FieldPermissionV2 } from '../FieldPermissionV2__';
 import type { ProcessElementV2 } from '../ProcessElementV2__';
 import type { OperatePermissionV2 } from '../OperatePermissionV2__';
 import type { AssigneeV2 } from '../AssigneeV2__';
+import type { DepartmentV2 } from '../DepartmentV2__';
+import type { DirectManagerV2 } from '../DirectManagerV2__';
+import type { DepartmentManagerV2 } from '../DepartmentManagerV2__';
 import type { FlowConditionV2 } from '../FlowConditionV2__';
 import type { SequentialPolicyV2 } from '../SequentialPolicyV2__';
 import type { CountersignPolicyV2 } from '../CountersignPolicyV2__';
@@ -178,6 +185,42 @@ export declare function isFileNode<T extends BaseNode>(node: T): node is T & Fil
  * 判断为文件节点
  */
 export declare function assertFileNode<T extends BaseNode>(node: T): asserts node is T & FileNode;
+/**
+ * 严格判断输入为 Annotation 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型为 Annotation
+ * }
+ * ```
+ */
+export declare function isStrictAnnotation(node: unknown): node is Annotation;
+/**
+ * 严格判断输入为 AnnotationProperty 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAnnotationProperty(node)) {
+ *   // 在这个花括号内，node 的类型为 AnnotationProperty
+ * }
+ * ```
+ */
+export declare function isStrictAnnotationProperty(node: unknown): node is AnnotationProperty;
+/**
+ * 严格判断输入为 ApplyAnnotation 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictApplyAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型为 ApplyAnnotation
+ * }
+ * ```
+ */
+export declare function isStrictApplyAnnotation(node: unknown): node is ApplyAnnotation;
 /**
  * 严格判断输入为 App 节点
  *
@@ -862,6 +905,18 @@ export declare function isStrictFrontendVariable(node: unknown): node is Fronten
  * ```
  */
 export declare function isStrictConstant(node: unknown): node is Constant;
+/**
+ * 严格判断输入为 SubLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSubLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 SubLogic
+ * }
+ * ```
+ */
+export declare function isStrictSubLogic(node: unknown): node is SubLogic;
 /**
  * 严格判断输入为 Function 节点
  *
@@ -2062,6 +2117,42 @@ export declare function isStrictOperatePermissionV2(node: unknown): node is Oper
  * ```
  */
 export declare function isStrictAssigneeV2(node: unknown): node is AssigneeV2;
+/**
+ * 严格判断输入为 DepartmentV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDepartmentV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DepartmentV2
+ * }
+ * ```
+ */
+export declare function isStrictDepartmentV2(node: unknown): node is DepartmentV2;
+/**
+ * 严格判断输入为 DirectManagerV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDirectManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DirectManagerV2
+ * }
+ * ```
+ */
+export declare function isStrictDirectManagerV2(node: unknown): node is DirectManagerV2;
+/**
+ * 严格判断输入为 DepartmentManagerV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDepartmentManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DepartmentManagerV2
+ * }
+ * ```
+ */
+export declare function isStrictDepartmentManagerV2(node: unknown): node is DepartmentManagerV2;
 /**
  * 严格判断输入为 FlowConditionV2 节点
  *
@@ -2110,6 +2201,58 @@ export declare function isStrictCountersignPolicyV2(node: unknown): node is Coun
  * ```
  */
 export declare function isStrictOrSignPolicyV2(node: unknown): node is OrSignPolicyV2;
+/**
+ * 判断输入为 Annotation 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Annotation 节点没有继承类，此判断等价于`isStrictAnnotation`
+ * @example
+ * ```ts
+ * if (isAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型是 Annotation 或者 Annotation 继承类型
+ * }
+ * ```
+ */
+export declare function isAnnotation(node: unknown): node is Annotation;
+/**
+ * 判断输入为 AnnotationProperty 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，AnnotationProperty 节点没有继承类，此判断等价于`isStrictAnnotationProperty`
+ * @example
+ * ```ts
+ * if (isAnnotationProperty(node)) {
+ *   // 在这个花括号内，node 的类型是 AnnotationProperty 或者 AnnotationProperty 继承类型
+ * }
+ * ```
+ */
+export declare function isAnnotationProperty(node: unknown): node is AnnotationProperty;
+/**
+ * 判断输入为 Annotatable 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isAnnotatable(node)) {
+ *   // 在这个花括号内，node 的类型是 Annotatable 或者 Annotatable 继承类型
+ * }
+ * ```
+ */
+export declare function isAnnotatable(node: unknown): node is types.AnnotatableNode;
+/**
+ * 判断输入为 ApplyAnnotation 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ApplyAnnotation 节点没有继承类，此判断等价于`isStrictApplyAnnotation`
+ * @example
+ * ```ts
+ * if (isApplyAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型是 ApplyAnnotation 或者 ApplyAnnotation 继承类型
+ * }
+ * ```
+ */
+export declare function isApplyAnnotation(node: unknown): node is ApplyAnnotation;
 /**
  * 判断输入为 App 节点实例
  *
@@ -2890,6 +3033,19 @@ export declare function isConstant(node: unknown): node is Constant;
  * ```
  */
 export declare function isLogicItem(node: unknown): node is types.LogicItemNode;
+/**
+ * 判断输入为 SubLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SubLogic 节点没有继承类，此判断等价于`isStrictSubLogic`
+ * @example
+ * ```ts
+ * if (isSubLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 SubLogic 或者 SubLogic 继承类型
+ * }
+ * ```
+ */
+export declare function isSubLogic(node: unknown): node is SubLogic;
 /**
  * 判断输入为 Function 节点实例
  *
@@ -4229,6 +4385,58 @@ export declare function isOperatePermissionV2(node: unknown): node is OperatePer
  * ```
  */
 export declare function isAssigneeV2(node: unknown): node is AssigneeV2;
+/**
+ * 判断输入为 DepartmentV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DepartmentV2 节点没有继承类，此判断等价于`isStrictDepartmentV2`
+ * @example
+ * ```ts
+ * if (isDepartmentV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DepartmentV2 或者 DepartmentV2 继承类型
+ * }
+ * ```
+ */
+export declare function isDepartmentV2(node: unknown): node is DepartmentV2;
+/**
+ * 判断输入为 ManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 ManagerV2 或者 ManagerV2 继承类型
+ * }
+ * ```
+ */
+export declare function isManagerV2(node: unknown): node is types.ManagerV2Node;
+/**
+ * 判断输入为 DirectManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DirectManagerV2 节点没有继承类，此判断等价于`isStrictDirectManagerV2`
+ * @example
+ * ```ts
+ * if (isDirectManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DirectManagerV2 或者 DirectManagerV2 继承类型
+ * }
+ * ```
+ */
+export declare function isDirectManagerV2(node: unknown): node is DirectManagerV2;
+/**
+ * 判断输入为 DepartmentManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DepartmentManagerV2 节点没有继承类，此判断等价于`isStrictDepartmentManagerV2`
+ * @example
+ * ```ts
+ * if (isDepartmentManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DepartmentManagerV2 或者 DepartmentManagerV2 继承类型
+ * }
+ * ```
+ */
+export declare function isDepartmentManagerV2(node: unknown): node is DepartmentManagerV2;
 /**
  * 判断输入为 FlowConditionV2 节点实例
  *
@@ -4294,6 +4502,42 @@ export declare function isCountersignPolicyV2(node: unknown): node is Countersig
  * ```
  */
 export declare function isOrSignPolicyV2(node: unknown): node is OrSignPolicyV2;
+/**
+ * 严格断言为 Annotation 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotation 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictAnnotation(node: unknown): asserts node is Annotation;
+/**
+ * 严格断言为 AnnotationProperty 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictAnnotationProperty(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnnotationProperty 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictAnnotationProperty(node: unknown): asserts node is AnnotationProperty;
+/**
+ * 严格断言为 ApplyAnnotation 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictApplyAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ApplyAnnotation 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictApplyAnnotation(node: unknown): asserts node is ApplyAnnotation;
 /**
  * 严格断言为 App 节点
  *
@@ -4978,6 +5222,18 @@ export declare function assertStrictFrontendVariable(node: unknown): asserts nod
  * ```
  */
 export declare function assertStrictConstant(node: unknown): asserts node is Constant;
+/**
+ * 严格断言为 SubLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSubLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictSubLogic(node: unknown): asserts node is SubLogic;
 /**
  * 严格断言为 Function 节点
  *
@@ -6178,6 +6434,42 @@ export declare function assertStrictOperatePermissionV2(node: unknown): asserts
  * ```
  */
 export declare function assertStrictAssigneeV2(node: unknown): asserts node is AssigneeV2;
+/**
+ * 严格断言为 DepartmentV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDepartmentV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictDepartmentV2(node: unknown): asserts node is DepartmentV2;
+/**
+ * 严格断言为 DirectManagerV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDirectManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DirectManagerV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictDirectManagerV2(node: unknown): asserts node is DirectManagerV2;
+/**
+ * 严格断言为 DepartmentManagerV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDepartmentManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentManagerV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertStrictDepartmentManagerV2(node: unknown): asserts node is DepartmentManagerV2;
 /**
  * 严格断言为 FlowConditionV2 节点
  *
@@ -6226,6 +6518,58 @@ export declare function assertStrictCountersignPolicyV2(node: unknown): asserts
  * ```
  */
 export declare function assertStrictOrSignPolicyV2(node: unknown): asserts node is OrSignPolicyV2;
+/**
+ * 断言为 Annotation 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotation`方法
+ * @example
+ * ```ts
+ * assertAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotation 或者 Annotation 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertAnnotation(node: unknown): asserts node is Annotation;
+/**
+ * 断言为 AnnotationProperty 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotationProperty`方法
+ * @example
+ * ```ts
+ * assertAnnotationProperty(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnnotationProperty 或者 AnnotationProperty 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertAnnotationProperty(node: unknown): asserts node is AnnotationProperty;
+/**
+ * 断言为 Annotatable 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotatable`方法
+ * @example
+ * ```ts
+ * assertAnnotatable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotatable 或者 Annotatable 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertAnnotatable(node: unknown): asserts node is types.AnnotatableNode;
+/**
+ * 断言为 ApplyAnnotation 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictApplyAnnotation`方法
+ * @example
+ * ```ts
+ * assertApplyAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ApplyAnnotation 或者 ApplyAnnotation 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertApplyAnnotation(node: unknown): asserts node is ApplyAnnotation;
 /**
  * 断言为 App 节点
  *
@@ -7006,6 +7350,19 @@ export declare function assertConstant(node: unknown): asserts node is Constant;
  * ```
  */
 export declare function assertLogicItem(node: unknown): asserts node is types.LogicItemNode;
+/**
+ * 断言为 SubLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSubLogic`方法
+ * @example
+ * ```ts
+ * assertSubLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubLogic 或者 SubLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertSubLogic(node: unknown): asserts node is SubLogic;
 /**
  * 断言为 Function 节点
  *
@@ -8345,6 +8702,58 @@ export declare function assertOperatePermissionV2(node: unknown): asserts node i
  * ```
  */
 export declare function assertAssigneeV2(node: unknown): asserts node is AssigneeV2;
+/**
+ * 断言为 DepartmentV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDepartmentV2`方法
+ * @example
+ * ```ts
+ * assertDepartmentV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentV2 或者 DepartmentV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertDepartmentV2(node: unknown): asserts node is DepartmentV2;
+/**
+ * 断言为 ManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictManagerV2`方法
+ * @example
+ * ```ts
+ * assertManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ManagerV2 或者 ManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertManagerV2(node: unknown): asserts node is types.ManagerV2Node;
+/**
+ * 断言为 DirectManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDirectManagerV2`方法
+ * @example
+ * ```ts
+ * assertDirectManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DirectManagerV2 或者 DirectManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertDirectManagerV2(node: unknown): asserts node is DirectManagerV2;
+/**
+ * 断言为 DepartmentManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDepartmentManagerV2`方法
+ * @example
+ * ```ts
+ * assertDepartmentManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentManagerV2 或者 DepartmentManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export declare function assertDepartmentManagerV2(node: unknown): asserts node is DepartmentManagerV2;
 /**
  * 断言为 FlowConditionV2 节点
  *