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

package/src/concepts/utils/asserts.ts

@@ -1,3 +1,7 @@
+import type { Annotation } from '../Annotation__';
+import type { AnnotationProperty } from '../AnnotationProperty__';
+import type { Annotatable } from '../Annotatable__';
+import type { ApplyAnnotation } from '../ApplyAnnotation__';
 import type { App } from '../App__';
 import type { Module } from '../Module__';
 import type { Namespace } from '../Namespace__';
@@ -58,6 +62,7 @@ import type { BackendVariable } from '../BackendVariable__';
 import type { FrontendVariable } from '../FrontendVariable__';
 import type { Constant } from '../Constant__';
 import type { LogicItem } from '../LogicItem__';
+import type { SubLogic } from '../SubLogic__';
 import type { Function } from '../Function__';
 import type { AnonymousFunction } from '../AnonymousFunction__';
 import type { ImportedInterface } from '../ImportedInterface__';
@@ -161,6 +166,10 @@ 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 { ManagerV2 } from '../ManagerV2__';
+import type { DirectManagerV2 } from '../DirectManagerV2__';
+import type { DepartmentManagerV2 } from '../DepartmentManagerV2__';
 import type { FlowConditionV2 } from '../FlowConditionV2__';
 import type { ApprovalPolicyV2 } from '../ApprovalPolicyV2__';
 import type { SequentialPolicyV2 } from '../SequentialPolicyV2__';
@@ -204,6 +213,51 @@ export function assertFileNode<T extends BaseNode>(node: T): asserts node is T &
 
 //=========== 以下为严格类型判断 ===========
 
+/**
+ * 严格判断输入为 Annotation 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型为 Annotation
+ * }
+ * ```
+ */
+export function isStrictAnnotation(node: unknown): node is Annotation {
+  return isBaseNode(node) && node.concept === 'Annotation';
+}
+
+/**
+ * 严格判断输入为 AnnotationProperty 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictAnnotationProperty(node)) {
+ *   // 在这个花括号内，node 的类型为 AnnotationProperty
+ * }
+ * ```
+ */
+export function isStrictAnnotationProperty(node: unknown): node is AnnotationProperty {
+  return isBaseNode(node) && node.concept === 'AnnotationProperty';
+}
+
+/**
+ * 严格判断输入为 ApplyAnnotation 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictApplyAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型为 ApplyAnnotation
+ * }
+ * ```
+ */
+export function isStrictApplyAnnotation(node: unknown): node is ApplyAnnotation {
+  return isBaseNode(node) && node.concept === 'ApplyAnnotation';
+}
+
 /**
  * 严格判断输入为 App 节点
  *
@@ -1059,6 +1113,21 @@ export function isStrictConstant(node: unknown): node is Constant {
   return isBaseNode(node) && node.concept === 'Constant';
 }
 
+/**
+ * 严格判断输入为 SubLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictSubLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 SubLogic
+ * }
+ * ```
+ */
+export function isStrictSubLogic(node: unknown): node is SubLogic {
+  return isBaseNode(node) && node.concept === 'SubLogic';
+}
+
 /**
  * 严格判断输入为 Function 节点
  *
@@ -2559,6 +2628,51 @@ export function isStrictAssigneeV2(node: unknown): node is AssigneeV2 {
   return isBaseNode(node) && node.concept === 'AssigneeV2';
 }
 
+/**
+ * 严格判断输入为 DepartmentV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDepartmentV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DepartmentV2
+ * }
+ * ```
+ */
+export function isStrictDepartmentV2(node: unknown): node is DepartmentV2 {
+  return isBaseNode(node) && node.concept === 'DepartmentV2';
+}
+
+/**
+ * 严格判断输入为 DirectManagerV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDirectManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DirectManagerV2
+ * }
+ * ```
+ */
+export function isStrictDirectManagerV2(node: unknown): node is DirectManagerV2 {
+  return isBaseNode(node) && node.concept === 'DirectManagerV2';
+}
+
+/**
+ * 严格判断输入为 DepartmentManagerV2 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictDepartmentManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型为 DepartmentManagerV2
+ * }
+ * ```
+ */
+export function isStrictDepartmentManagerV2(node: unknown): node is DepartmentManagerV2 {
+  return isBaseNode(node) && node.concept === 'DepartmentManagerV2';
+}
+
 /**
  * 严格判断输入为 FlowConditionV2 节点
  *
@@ -2623,6 +2737,98 @@ export function isStrictOrSignPolicyV2(node: unknown): node is OrSignPolicyV2 {
 
 //=========== 以下为继承类型判断 ===========
 
+/**
+ * 判断输入为 Annotation 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，Annotation 节点没有继承类，此判断等价于`isStrictAnnotation`
+ * @example
+ * ```ts
+ * if (isAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型是 Annotation 或者 Annotation 继承类型
+ * }
+ * ```
+ */
+export function isAnnotation(node: unknown): node is Annotation {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'Annotation'
+    )
+  );
+}
+
+/**
+ * 判断输入为 AnnotationProperty 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，AnnotationProperty 节点没有继承类，此判断等价于`isStrictAnnotationProperty`
+ * @example
+ * ```ts
+ * if (isAnnotationProperty(node)) {
+ *   // 在这个花括号内，node 的类型是 AnnotationProperty 或者 AnnotationProperty 继承类型
+ * }
+ * ```
+ */
+export function isAnnotationProperty(node: unknown): node is AnnotationProperty {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'AnnotationProperty'
+    )
+  );
+}
+
+/**
+ * 判断输入为 Annotatable 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isAnnotatable(node)) {
+ *   // 在这个花括号内，node 的类型是 Annotatable 或者 Annotatable 继承类型
+ * }
+ * ```
+ */
+export function isAnnotatable(node: unknown): node is types.AnnotatableNode {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'Annotatable' ||
+      node.concept === 'Entity' ||
+      node.concept === 'View' ||
+      node.concept === 'ViewElement' ||
+      node.concept === 'Logic' ||
+      node.concept === 'AuthLogic' ||
+      node.concept === 'AuthLogicForCallInterface' ||
+      node.concept === 'BusinessLogic' ||
+      node.concept === 'ConnectorLogic'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ApplyAnnotation 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ApplyAnnotation 节点没有继承类，此判断等价于`isStrictApplyAnnotation`
+ * @example
+ * ```ts
+ * if (isApplyAnnotation(node)) {
+ *   // 在这个花括号内，node 的类型是 ApplyAnnotation 或者 ApplyAnnotation 继承类型
+ * }
+ * ```
+ */
+export function isApplyAnnotation(node: unknown): node is ApplyAnnotation {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ApplyAnnotation'
+    )
+  );
+}
+
 /**
  * 判断输入为 App 节点实例
  *
@@ -3898,6 +4104,7 @@ export function isLogicItem(node: unknown): node is types.LogicItemNode {
     isBaseNode(node) &&
     (
       node.concept === 'LogicItem' ||
+      node.concept === 'SubLogic' ||
       node.concept === 'AnonymousFunction' ||
       node.concept === 'Abort' ||
       node.concept === 'Start' ||
@@ -3959,6 +4166,27 @@ export function isLogicItem(node: unknown): node is types.LogicItemNode {
   );
 }
 
+/**
+ * 判断输入为 SubLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，SubLogic 节点没有继承类，此判断等价于`isStrictSubLogic`
+ * @example
+ * ```ts
+ * if (isSubLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 SubLogic 或者 SubLogic 继承类型
+ * }
+ * ```
+ */
+export function isSubLogic(node: unknown): node is SubLogic {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'SubLogic'
+    )
+  );
+}
+
 /**
  * 判断输入为 Function 节点实例
  *
@@ -6135,6 +6363,92 @@ export function isAssigneeV2(node: unknown): node is AssigneeV2 {
   );
 }
 
+/**
+ * 判断输入为 DepartmentV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DepartmentV2 节点没有继承类，此判断等价于`isStrictDepartmentV2`
+ * @example
+ * ```ts
+ * if (isDepartmentV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DepartmentV2 或者 DepartmentV2 继承类型
+ * }
+ * ```
+ */
+export function isDepartmentV2(node: unknown): node is DepartmentV2 {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'DepartmentV2'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 ManagerV2 或者 ManagerV2 继承类型
+ * }
+ * ```
+ */
+export function isManagerV2(node: unknown): node is types.ManagerV2Node {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ManagerV2' ||
+      node.concept === 'DirectManagerV2' ||
+      node.concept === 'DepartmentManagerV2'
+    )
+  );
+}
+
+/**
+ * 判断输入为 DirectManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DirectManagerV2 节点没有继承类，此判断等价于`isStrictDirectManagerV2`
+ * @example
+ * ```ts
+ * if (isDirectManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DirectManagerV2 或者 DirectManagerV2 继承类型
+ * }
+ * ```
+ */
+export function isDirectManagerV2(node: unknown): node is DirectManagerV2 {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'DirectManagerV2'
+    )
+  );
+}
+
+/**
+ * 判断输入为 DepartmentManagerV2 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，DepartmentManagerV2 节点没有继承类，此判断等价于`isStrictDepartmentManagerV2`
+ * @example
+ * ```ts
+ * if (isDepartmentManagerV2(node)) {
+ *   // 在这个花括号内，node 的类型是 DepartmentManagerV2 或者 DepartmentManagerV2 继承类型
+ * }
+ * ```
+ */
+export function isDepartmentManagerV2(node: unknown): node is DepartmentManagerV2 {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'DepartmentManagerV2'
+    )
+  );
+}
+
 /**
  * 判断输入为 FlowConditionV2 节点实例
  *
@@ -6247,6 +6561,57 @@ export function isOrSignPolicyV2(node: unknown): node is OrSignPolicyV2 {
 
 //=========== 以下为严格类型断言 ===========
 
+/**
+ * 严格断言为 Annotation 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotation 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictAnnotation(node: unknown): asserts node is Annotation {
+  if (!isStrictAnnotation(node)) {
+    throw new Error(`Annotation 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 AnnotationProperty 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictAnnotationProperty(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnnotationProperty 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictAnnotationProperty(node: unknown): asserts node is AnnotationProperty {
+  if (!isStrictAnnotationProperty(node)) {
+    throw new Error(`AnnotationProperty 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 ApplyAnnotation 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictApplyAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ApplyAnnotation 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictApplyAnnotation(node: unknown): asserts node is ApplyAnnotation {
+  if (!isStrictApplyAnnotation(node)) {
+    throw new Error(`ApplyAnnotation 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 App 节点
  *
@@ -7216,6 +7581,23 @@ export function assertStrictConstant(node: unknown): asserts node is Constant {
   }
 }
 
+/**
+ * 严格断言为 SubLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictSubLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictSubLogic(node: unknown): asserts node is SubLogic {
+  if (!isStrictSubLogic(node)) {
+    throw new Error(`SubLogic 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 Function 节点
  *
@@ -8916,6 +9298,57 @@ export function assertStrictAssigneeV2(node: unknown): asserts node is AssigneeV
   }
 }
 
+/**
+ * 严格断言为 DepartmentV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDepartmentV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictDepartmentV2(node: unknown): asserts node is DepartmentV2 {
+  if (!isStrictDepartmentV2(node)) {
+    throw new Error(`DepartmentV2 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 DirectManagerV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDirectManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DirectManagerV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictDirectManagerV2(node: unknown): asserts node is DirectManagerV2 {
+  if (!isStrictDirectManagerV2(node)) {
+    throw new Error(`DirectManagerV2 节点严格断言失败`);
+  }
+}
+
+/**
+ * 严格断言为 DepartmentManagerV2 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictDepartmentManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentManagerV2 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictDepartmentManagerV2(node: unknown): asserts node is DepartmentManagerV2 {
+  if (!isStrictDepartmentManagerV2(node)) {
+    throw new Error(`DepartmentManagerV2 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 FlowConditionV2 节点
  *
@@ -8988,6 +9421,78 @@ export function assertStrictOrSignPolicyV2(node: unknown): asserts node is OrSig
 
 //=========== 以下为继承类型断言 ===========
 
+/**
+ * 断言为 Annotation 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotation`方法
+ * @example
+ * ```ts
+ * assertAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotation 或者 Annotation 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertAnnotation(node: unknown): asserts node is Annotation {
+  if (!isAnnotation(node)) {
+    throw new Error(`Annotation 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 AnnotationProperty 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotationProperty`方法
+ * @example
+ * ```ts
+ * assertAnnotationProperty(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnnotationProperty 或者 AnnotationProperty 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertAnnotationProperty(node: unknown): asserts node is AnnotationProperty {
+  if (!isAnnotationProperty(node)) {
+    throw new Error(`AnnotationProperty 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 Annotatable 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictAnnotatable`方法
+ * @example
+ * ```ts
+ * assertAnnotatable(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Annotatable 或者 Annotatable 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertAnnotatable(node: unknown): asserts node is types.AnnotatableNode {
+  if (!isAnnotatable(node)) {
+    throw new Error(`Annotatable 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 ApplyAnnotation 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictApplyAnnotation`方法
+ * @example
+ * ```ts
+ * assertApplyAnnotation(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ApplyAnnotation 或者 ApplyAnnotation 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertApplyAnnotation(node: unknown): asserts node is ApplyAnnotation {
+  if (!isApplyAnnotation(node)) {
+    throw new Error(`ApplyAnnotation 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 App 节点
  *
@@ -10068,6 +10573,24 @@ export function assertLogicItem(node: unknown): asserts node is types.LogicItemN
   }
 }
 
+/**
+ * 断言为 SubLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictSubLogic`方法
+ * @example
+ * ```ts
+ * assertSubLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubLogic 或者 SubLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertSubLogic(node: unknown): asserts node is SubLogic {
+  if (!isSubLogic(node)) {
+    throw new Error(`SubLogic 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 Function 节点
  *
@@ -11922,6 +12445,78 @@ export function assertAssigneeV2(node: unknown): asserts node is AssigneeV2 {
   }
 }
 
+/**
+ * 断言为 DepartmentV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDepartmentV2`方法
+ * @example
+ * ```ts
+ * assertDepartmentV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentV2 或者 DepartmentV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertDepartmentV2(node: unknown): asserts node is DepartmentV2 {
+  if (!isDepartmentV2(node)) {
+    throw new Error(`DepartmentV2 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 ManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictManagerV2`方法
+ * @example
+ * ```ts
+ * assertManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ManagerV2 或者 ManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertManagerV2(node: unknown): asserts node is types.ManagerV2Node {
+  if (!isManagerV2(node)) {
+    throw new Error(`ManagerV2 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 DirectManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDirectManagerV2`方法
+ * @example
+ * ```ts
+ * assertDirectManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DirectManagerV2 或者 DirectManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertDirectManagerV2(node: unknown): asserts node is DirectManagerV2 {
+  if (!isDirectManagerV2(node)) {
+    throw new Error(`DirectManagerV2 节点断言失败`);
+  }
+}
+
+/**
+ * 断言为 DepartmentManagerV2 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictDepartmentManagerV2`方法
+ * @example
+ * ```ts
+ * assertDepartmentManagerV2(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentManagerV2 或者 DepartmentManagerV2 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertDepartmentManagerV2(node: unknown): asserts node is DepartmentManagerV2 {
+  if (!isDepartmentManagerV2(node)) {
+    throw new Error(`DepartmentManagerV2 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 FlowConditionV2 节点
  *