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__';
import type { Directory } from '../Directory__';
import type { ReferredDefinition } from '../ReferredDefinition__';
import type { FrontendType } from '../FrontendType__';
import type { Frontend } from '../Frontend__';
import type { Backend } from '../Backend__';
import type { Integration } from '../Integration__';
import type { MicroApp } from '../MicroApp__';
import type { TypeAnnotation } from '../TypeAnnotation__';
import type { DatabaseTypeAnnotation } from '../DatabaseTypeAnnotation__';
import type { TypeParam } from '../TypeParam__';
import type { Structure } from '../Structure__';
import type { StructureProperty } from '../StructureProperty__';
import type { Enum } from '../Enum__';
import type { EnumItem } from '../EnumItem__';
import type { DataSource } from '../DataSource__';
import type { Entity } from '../Entity__';
import type { EntityProperty } from '../EntityProperty__';
import type { EntityIndex } from '../EntityIndex__';
import type { MetadataType } from '../MetadataType__';
import type { View } from '../View__';
import type { ViewElement } from '../ViewElement__';
import type { BindAttribute } from '../BindAttribute__';
import type { BindDirective } from '../BindDirective__';
import type { BindEvent } from '../BindEvent__';
import type { BindStyle } from '../BindStyle__';
import type { ThemeVariable } from '../ThemeVariable__';
import type { CustomSetter } from '../CustomSetter__';
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 { PropertyTransformSetter } from '../PropertyTransformSetter__';
import type { AnonymousFunctionSetter } from '../AnonymousFunctionSetter__';
import type { DataSourceSetter } from '../DataSourceSetter__';
import type { ViewComponentDeclaration } from '../ViewComponentDeclaration__';
import type { BusinessComponent } from '../BusinessComponent__';
import type { Attribute } from '../Attribute__';
import type { Event } from '../Event__';
import type { PropDeclaration } from '../PropDeclaration__';
import type { EventDeclaration } from '../EventDeclaration__';
import type { SlotDeclaration } from '../SlotDeclaration__';
import type { LogicDeclaration } from '../LogicDeclaration__';
import type { CSSRule } from '../CSSRule__';
import type { Theme } from '../Theme__';
import type { Slot } from '../Slot__';
import type { ViewComponent } from '../ViewComponent__';
import type { Logic } from '../Logic__';
import type { SharedScope } from '../SharedScope__';
import type { PermissionForSharedScope } from '../PermissionForSharedScope__';
import type { AuthLogic } from '../AuthLogic__';
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__';
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 { RetryConfig } from '../RetryConfig__';
import type { Interface } from '../Interface__';
import type { McpInterface } from '../McpInterface__';
import type { ConnectionInfo } from '../ConnectionInfo__';
import type { MicroserviceInterface } from '../MicroserviceInterface__';
import type { GatewayInterface } from '../GatewayInterface__';
import type { InterfaceParam } from '../InterfaceParam__';
import type { Transactional } from '../Transactional__';
import type { DefaultValue } from '../DefaultValue__';
import type { Abort } from '../Abort__';
import type { Start } from '../Start__';
import type { End } from '../End__';
import type { IfStatement } from '../IfStatement__';
import type { IfExpression } from '../IfExpression__';
import type { SwitchStatement } from '../SwitchStatement__';
import type { SwitchCase } from '../SwitchCase__';
import type { ForEachStatement } from '../ForEachStatement__';
import type { WhileStatement } from '../WhileStatement__';
import type { Break } from '../Break__';
import type { Continue } from '../Continue__';
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 { CallMicroserviceInterface } from '../CallMicroserviceInterface__';
import type { CallGatewayInterface } from '../CallGatewayInterface__';
import type { Destination } from '../Destination__';
import type { ExternalDestination } from '../ExternalDestination__';
import type { ValidationRule } from '../ValidationRule__';
import type { ValidationLogic } from '../ValidationLogic__';
import type { Argument } from '../Argument__';
import type { Anchor } from '../Anchor__';
import type { JSBlock } from '../JSBlock__';
import type { JavaLogic } from '../JavaLogic__';
import type { Block } from '../Block__';
import type { Identifier } from '../Identifier__';
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 { VariadicExpression } from '../VariadicExpression__';
import type { MatchCase } from '../MatchCase__';
import type { Match } from '../Match__';
import type { UnaryExpression } from '../UnaryExpression__';
import type { MemberExpression } from '../MemberExpression__';
import type { Unparsed } from '../Unparsed__';
import type { New } from '../New__';
import type { NewComposite } from '../NewComposite__';
import type { NewStructure } from '../NewStructure__';
import type { NewList } from '../NewList__';
import type { NewMap } from '../NewMap__';
import type { NewRegex } from '../NewRegex__';
import type { Paginate } from '../Paginate__';
import type { CallQueryComponent } from '../CallQueryComponent__';
import type { QuerySelectExpression } from '../QuerySelectExpression__';
import type { QueryFromExpression } from '../QueryFromExpression__';
import type { QueryJoinExpression } from '../QueryJoinExpression__';
import type { QueryFieldExpression } from '../QueryFieldExpression__';
import type { QueryAggregateExpression } from '../QueryAggregateExpression__';
import type { QueryOrderByExpression } from '../QueryOrderByExpression__';
import type { QueryGroupByExpression } from '../QueryGroupByExpression__';
import type { QueryLimitExpression } from '../QueryLimitExpression__';
import type { SqlQueryComponent } from '../SqlQueryComponent__';
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 { Role } from '../Role__';
import type { Configuration } from '../Configuration__';
import type { ConfigGroup } from '../ConfigGroup__';
import type { ConfigProperty } from '../ConfigProperty__';
import type { ConfigPropertyValue } from '../ConfigPropertyValue__';
import type { I18nInfo } from '../I18nInfo__';
import type { StyleInfo } from '../StyleInfo__';
import type { CompletionProperty } from '../CompletionProperty__';
import type { UseComponent } from '../UseComponent__';
import type { Point } from '../Point__';
import type { Rect } from '../Rect__';
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 { MsgTriggerEvent } from '../MsgTriggerEvent__';
import type { InterfaceTriggerEvent } from '../InterfaceTriggerEvent__';
import type { ConnectorTrigger } from '../ConnectorTrigger__';
import type { TriggerLauncher } from '../TriggerLauncher__';
import type { ConnectorTriggerLauncher } from '../ConnectorTriggerLauncher__';
import type { MsgTriggerLauncher } from '../MsgTriggerLauncher__';
import type { Dependency } from '../Dependency__';
import type { Connector } from '../Connector__';
import type { CallConnector } from '../CallConnector__';
import type { Connection } from '../Connection__';
import type { ConnectorLogic } from '../ConnectorLogic__';
import type { ProcessV2 } from '../ProcessV2__';
import type { ProcessDefinitionV2 } from '../ProcessDefinitionV2__';
import type { HistoryProcessV2 } from '../HistoryProcessV2__';
import type { ProcessBindV2 } from '../ProcessBindV2__';
import type { FieldPermissionV2 } from '../FieldPermissionV2__';
import type { ProcessElementV2 } from '../ProcessElementV2__';
import type { SubProcessDataMappingRule } from '../SubProcessDataMappingRule__';
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 { UserAssignees } from '../UserAssignees__';
import type { RoleAssignees } from '../RoleAssignees__';
import type { DepartmentAssignees } from '../DepartmentAssignees__';
import type { FlowConditionV2 } from '../FlowConditionV2__';
import type { SequentialPolicyV2 } from '../SequentialPolicyV2__';
import type { CountersignPolicyV2 } from '../CountersignPolicyV2__';
import type { OrSignPolicyV2 } from '../OrSignPolicyV2__';
import type { AutoApproveUnmannedV2 } from '../AutoApproveUnmannedV2__';
import type { AutoRejectUnmannedV2 } from '../AutoRejectUnmannedV2__';
import type { ReassignUnmannedV2 } from '../ReassignUnmannedV2__';
import type * as types from './types';
import type { BaseNode } from '../../common';
import type { Embedded } from '@lcap/nasl-types';
/**
 * 判断为节点
 */
export declare function isBaseNode(node: unknown): node is BaseNode;
/**
 * 断言为节点
 */
export declare function assertBaseNode(node: unknown): asserts node is BaseNode;
/**
 * 判断为文件节点
 */
export declare function isFileNode<T extends BaseNode>(node: T): node is Embedded.FileNode<T>;
/**
 * 判断为文件节点
 */
export declare function assertFileNode<T extends BaseNode>(node: T): asserts node is Embedded.FileNode<T>;
/**
 * 严格判断输入为 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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictApp(node)) {
 *   // 在这个花括号内，node 的类型为 App
 * }
 * ```
 */
export declare function isStrictApp(node: unknown): node is App;
/**
 * 严格判断输入为 Module 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictModule(node)) {
 *   // 在这个花括号内，node 的类型为 Module
 * }
 * ```
 */
export declare function isStrictModule(node: unknown): node is Module;
/**
 * 严格判断输入为 Namespace 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNamespace(node)) {
 *   // 在这个花括号内，node 的类型为 Namespace
 * }
 * ```
 */
export declare function isStrictNamespace(node: unknown): node is Namespace;
/**
 * 严格判断输入为 Directory 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDirectory(node)) {
 *   // 在这个花括号内，node 的类型为 Directory
 * }
 * ```
 */
export declare function isStrictDirectory(node: unknown): node is Directory;
/**
 * 严格判断输入为 ReferredDefinition 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictReferredDefinition(node)) {
 *   // 在这个花括号内，node 的类型为 ReferredDefinition
 * }
 * ```
 */
export declare function isStrictReferredDefinition(node: unknown): node is ReferredDefinition;
/**
 * 严格判断输入为 FrontendType 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFrontendType(node)) {
 *   // 在这个花括号内，node 的类型为 FrontendType
 * }
 * ```
 */
export declare function isStrictFrontendType(node: unknown): node is FrontendType;
/**
 * 严格判断输入为 Frontend 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFrontend(node)) {
 *   // 在这个花括号内，node 的类型为 Frontend
 * }
 * ```
 */
export declare function isStrictFrontend(node: unknown): node is Frontend;
/**
 * 严格判断输入为 Backend 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBackend(node)) {
 *   // 在这个花括号内，node 的类型为 Backend
 * }
 * ```
 */
export declare function isStrictBackend(node: unknown): node is Backend;
/**
 * 严格判断输入为 Integration 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictIntegration(node)) {
 *   // 在这个花括号内，node 的类型为 Integration
 * }
 * ```
 */
export declare function isStrictIntegration(node: unknown): node is Integration;
/**
 * 严格判断输入为 MicroApp 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMicroApp(node)) {
 *   // 在这个花括号内，node 的类型为 MicroApp
 * }
 * ```
 */
export declare function isStrictMicroApp(node: unknown): node is MicroApp;
/**
 * 严格判断输入为 TypeAnnotation 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictTypeAnnotation(node)) {
 *   // 在这个花括号内，node 的类型为 TypeAnnotation
 * }
 * ```
 */
export declare function isStrictTypeAnnotation(node: unknown): node is TypeAnnotation;
/**
 * 严格判断输入为 DatabaseTypeAnnotation 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDatabaseTypeAnnotation(node)) {
 *   // 在这个花括号内，node 的类型为 DatabaseTypeAnnotation
 * }
 * ```
 */
export declare function isStrictDatabaseTypeAnnotation(node: unknown): node is DatabaseTypeAnnotation;
/**
 * 严格判断输入为 TypeParam 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictTypeParam(node)) {
 *   // 在这个花括号内，node 的类型为 TypeParam
 * }
 * ```
 */
export declare function isStrictTypeParam(node: unknown): node is TypeParam;
/**
 * 严格判断输入为 Structure 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStructure(node)) {
 *   // 在这个花括号内，node 的类型为 Structure
 * }
 * ```
 */
export declare function isStrictStructure(node: unknown): node is Structure;
/**
 * 严格判断输入为 StructureProperty 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStructureProperty(node)) {
 *   // 在这个花括号内，node 的类型为 StructureProperty
 * }
 * ```
 */
export declare function isStrictStructureProperty(node: unknown): node is StructureProperty;
/**
 * 严格判断输入为 Enum 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEnum(node)) {
 *   // 在这个花括号内，node 的类型为 Enum
 * }
 * ```
 */
export declare function isStrictEnum(node: unknown): node is Enum;
/**
 * 严格判断输入为 EnumItem 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEnumItem(node)) {
 *   // 在这个花括号内，node 的类型为 EnumItem
 * }
 * ```
 */
export declare function isStrictEnumItem(node: unknown): node is EnumItem;
/**
 * 严格判断输入为 DataSource 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDataSource(node)) {
 *   // 在这个花括号内，node 的类型为 DataSource
 * }
 * ```
 */
export declare function isStrictDataSource(node: unknown): node is DataSource;
/**
 * 严格判断输入为 Entity 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEntity(node)) {
 *   // 在这个花括号内，node 的类型为 Entity
 * }
 * ```
 */
export declare function isStrictEntity(node: unknown): node is Entity;
/**
 * 严格判断输入为 EntityProperty 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEntityProperty(node)) {
 *   // 在这个花括号内，node 的类型为 EntityProperty
 * }
 * ```
 */
export declare function isStrictEntityProperty(node: unknown): node is EntityProperty;
/**
 * 严格判断输入为 EntityIndex 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEntityIndex(node)) {
 *   // 在这个花括号内，node 的类型为 EntityIndex
 * }
 * ```
 */
export declare function isStrictEntityIndex(node: unknown): node is EntityIndex;
/**
 * 严格判断输入为 MetadataType 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMetadataType(node)) {
 *   // 在这个花括号内，node 的类型为 MetadataType
 * }
 * ```
 */
export declare function isStrictMetadataType(node: unknown): node is MetadataType;
/**
 * 严格判断输入为 View 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictView(node)) {
 *   // 在这个花括号内，node 的类型为 View
 * }
 * ```
 */
export declare function isStrictView(node: unknown): node is View;
/**
 * 严格判断输入为 ViewElement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictViewElement(node)) {
 *   // 在这个花括号内，node 的类型为 ViewElement
 * }
 * ```
 */
export declare function isStrictViewElement(node: unknown): node is ViewElement;
/**
 * 严格判断输入为 BindAttribute 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBindAttribute(node)) {
 *   // 在这个花括号内，node 的类型为 BindAttribute
 * }
 * ```
 */
export declare function isStrictBindAttribute(node: unknown): node is BindAttribute;
/**
 * 严格判断输入为 BindDirective 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBindDirective(node)) {
 *   // 在这个花括号内，node 的类型为 BindDirective
 * }
 * ```
 */
export declare function isStrictBindDirective(node: unknown): node is BindDirective;
/**
 * 严格判断输入为 BindEvent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBindEvent(node)) {
 *   // 在这个花括号内，node 的类型为 BindEvent
 * }
 * ```
 */
export declare function isStrictBindEvent(node: unknown): node is BindEvent;
/**
 * 严格判断输入为 BindStyle 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBindStyle(node)) {
 *   // 在这个花括号内，node 的类型为 BindStyle
 * }
 * ```
 */
export declare function isStrictBindStyle(node: unknown): node is BindStyle;
/**
 * 严格判断输入为 ThemeVariable 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictThemeVariable(node)) {
 *   // 在这个花括号内，node 的类型为 ThemeVariable
 * }
 * ```
 */
export declare function isStrictThemeVariable(node: unknown): node is ThemeVariable;
/**
 * 严格判断输入为 CustomSetter 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCustomSetter(node)) {
 *   // 在这个花括号内，node 的类型为 CustomSetter
 * }
 * ```
 */
export declare function isStrictCustomSetter(node: unknown): node is CustomSetter;
/**
 * 严格判断输入为 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;
/**
 * 严格判断输入为 PropertyTransformSetter 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictPropertyTransformSetter(node)) {
 *   // 在这个花括号内，node 的类型为 PropertyTransformSetter
 * }
 * ```
 */
export declare function isStrictPropertyTransformSetter(node: unknown): node is PropertyTransformSetter;
/**
 * 严格判断输入为 AnonymousFunctionSetter 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAnonymousFunctionSetter(node)) {
 *   // 在这个花括号内，node 的类型为 AnonymousFunctionSetter
 * }
 * ```
 */
export declare function isStrictAnonymousFunctionSetter(node: unknown): node is AnonymousFunctionSetter;
/**
 * 严格判断输入为 DataSourceSetter 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDataSourceSetter(node)) {
 *   // 在这个花括号内，node 的类型为 DataSourceSetter
 * }
 * ```
 */
export declare function isStrictDataSourceSetter(node: unknown): node is DataSourceSetter;
/**
 * 严格判断输入为 ViewComponentDeclaration 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictViewComponentDeclaration(node)) {
 *   // 在这个花括号内，node 的类型为 ViewComponentDeclaration
 * }
 * ```
 */
export declare function isStrictViewComponentDeclaration(node: unknown): node is ViewComponentDeclaration;
/**
 * 严格判断输入为 BusinessComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBusinessComponent(node)) {
 *   // 在这个花括号内，node 的类型为 BusinessComponent
 * }
 * ```
 */
export declare function isStrictBusinessComponent(node: unknown): node is BusinessComponent;
/**
 * 严格判断输入为 Attribute 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAttribute(node)) {
 *   // 在这个花括号内，node 的类型为 Attribute
 * }
 * ```
 */
export declare function isStrictAttribute(node: unknown): node is Attribute;
/**
 * 严格判断输入为 Event 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEvent(node)) {
 *   // 在这个花括号内，node 的类型为 Event
 * }
 * ```
 */
export declare function isStrictEvent(node: unknown): node is Event;
/**
 * 严格判断输入为 PropDeclaration 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictPropDeclaration(node)) {
 *   // 在这个花括号内，node 的类型为 PropDeclaration
 * }
 * ```
 */
export declare function isStrictPropDeclaration(node: unknown): node is PropDeclaration;
/**
 * 严格判断输入为 EventDeclaration 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEventDeclaration(node)) {
 *   // 在这个花括号内，node 的类型为 EventDeclaration
 * }
 * ```
 */
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;
/**
 * 严格判断输入为 CSSRule 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCSSRule(node)) {
 *   // 在这个花括号内，node 的类型为 CSSRule
 * }
 * ```
 */
export declare function isStrictCSSRule(node: unknown): node is CSSRule;
/**
 * 严格判断输入为 Theme 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictTheme(node)) {
 *   // 在这个花括号内，node 的类型为 Theme
 * }
 * ```
 */
export declare function isStrictTheme(node: unknown): node is Theme;
/**
 * 严格判断输入为 Slot 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSlot(node)) {
 *   // 在这个花括号内，node 的类型为 Slot
 * }
 * ```
 */
export declare function isStrictSlot(node: unknown): node is Slot;
/**
 * 严格判断输入为 ViewComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictViewComponent(node)) {
 *   // 在这个花括号内，node 的类型为 ViewComponent
 * }
 * ```
 */
export declare function isStrictViewComponent(node: unknown): node is ViewComponent;
/**
 * 严格判断输入为 Logic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictLogic(node)) {
 *   // 在这个花括号内，node 的类型为 Logic
 * }
 * ```
 */
export declare function isStrictLogic(node: unknown): node is Logic;
/**
 * 严格判断输入为 SharedScope 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSharedScope(node)) {
 *   // 在这个花括号内，node 的类型为 SharedScope
 * }
 * ```
 */
export declare function isStrictSharedScope(node: unknown): node is SharedScope;
/**
 * 严格判断输入为 PermissionForSharedScope 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictPermissionForSharedScope(node)) {
 *   // 在这个花括号内，node 的类型为 PermissionForSharedScope
 * }
 * ```
 */
export declare function isStrictPermissionForSharedScope(node: unknown): node is PermissionForSharedScope;
/**
 * 严格判断输入为 AuthLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAuthLogic(node)) {
 *   // 在这个花括号内，node 的类型为 AuthLogic
 * }
 * ```
 */
export declare function isStrictAuthLogic(node: unknown): node is AuthLogic;
/**
 * 严格判断输入为 AuthLogicForCallInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAuthLogicForCallInterface(node)) {
 *   // 在这个花括号内，node 的类型为 AuthLogicForCallInterface
 * }
 * ```
 */
export declare function isStrictAuthLogicForCallInterface(node: unknown): node is AuthLogicForCallInterface;
/**
 * 严格判断输入为 OverriddenLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictOverriddenLogic(node)) {
 *   // 在这个花括号内，node 的类型为 OverriddenLogic
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictParam(node)) {
 *   // 在这个花括号内，node 的类型为 Param
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictReturn(node)) {
 *   // 在这个花括号内，node 的类型为 Return
 * }
 * ```
 */
export declare function isStrictReturn(node: unknown): node is Return;
/**
 * 严格判断输入为 Variable 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictVariable(node)) {
 *   // 在这个花括号内，node 的类型为 Variable
 * }
 * ```
 */
export declare function isStrictVariable(node: unknown): node is Variable;
/**
 * 严格判断输入为 BackendVariable 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBackendVariable(node)) {
 *   // 在这个花括号内，node 的类型为 BackendVariable
 * }
 * ```
 */
export declare function isStrictBackendVariable(node: unknown): node is BackendVariable;
/**
 * 严格判断输入为 FrontendVariable 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFrontendVariable(node)) {
 *   // 在这个花括号内，node 的类型为 FrontendVariable
 * }
 * ```
 */
export declare function isStrictFrontendVariable(node: unknown): node is FrontendVariable;
/**
 * 严格判断输入为 Constant 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConstant(node)) {
 *   // 在这个花括号内，node 的类型为 Constant
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFunction(node)) {
 *   // 在这个花括号内，node 的类型为 Function
 * }
 * ```
 */
export declare function isStrictFunction(node: unknown): node is Function;
/**
 * 严格判断输入为 AnonymousFunction 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAnonymousFunction(node)) {
 *   // 在这个花括号内，node 的类型为 AnonymousFunction
 * }
 * ```
 */
export declare function isStrictAnonymousFunction(node: unknown): node is AnonymousFunction;
/**
 * 严格判断输入为 RetryConfig 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictRetryConfig(node)) {
 *   // 在这个花括号内，node 的类型为 RetryConfig
 * }
 * ```
 */
export declare function isStrictRetryConfig(node: unknown): node is RetryConfig;
/**
 * 严格判断输入为 Interface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictInterface(node)) {
 *   // 在这个花括号内，node 的类型为 Interface
 * }
 * ```
 */
export declare function isStrictInterface(node: unknown): node is Interface;
/**
 * 严格判断输入为 McpInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMcpInterface(node)) {
 *   // 在这个花括号内，node 的类型为 McpInterface
 * }
 * ```
 */
export declare function isStrictMcpInterface(node: unknown): node is McpInterface;
/**
 * 严格判断输入为 ConnectionInfo 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnectionInfo(node)) {
 *   // 在这个花括号内，node 的类型为 ConnectionInfo
 * }
 * ```
 */
export declare function isStrictConnectionInfo(node: unknown): node is ConnectionInfo;
/**
 * 严格判断输入为 MicroserviceInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMicroserviceInterface(node)) {
 *   // 在这个花括号内，node 的类型为 MicroserviceInterface
 * }
 * ```
 */
export declare function isStrictMicroserviceInterface(node: unknown): node is MicroserviceInterface;
/**
 * 严格判断输入为 GatewayInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictGatewayInterface(node)) {
 *   // 在这个花括号内，node 的类型为 GatewayInterface
 * }
 * ```
 */
export declare function isStrictGatewayInterface(node: unknown): node is GatewayInterface;
/**
 * 严格判断输入为 InterfaceParam 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictInterfaceParam(node)) {
 *   // 在这个花括号内，node 的类型为 InterfaceParam
 * }
 * ```
 */
export declare function isStrictInterfaceParam(node: unknown): node is InterfaceParam;
/**
 * 严格判断输入为 Transactional 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictTransactional(node)) {
 *   // 在这个花括号内，node 的类型为 Transactional
 * }
 * ```
 */
export declare function isStrictTransactional(node: unknown): node is Transactional;
/**
 * 严格判断输入为 DefaultValue 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDefaultValue(node)) {
 *   // 在这个花括号内，node 的类型为 DefaultValue
 * }
 * ```
 */
export declare function isStrictDefaultValue(node: unknown): node is DefaultValue;
/**
 * 严格判断输入为 Abort 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAbort(node)) {
 *   // 在这个花括号内，node 的类型为 Abort
 * }
 * ```
 */
export declare function isStrictAbort(node: unknown): node is Abort;
/**
 * 严格判断输入为 Start 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStart(node)) {
 *   // 在这个花括号内，node 的类型为 Start
 * }
 * ```
 */
export declare function isStrictStart(node: unknown): node is Start;
/**
 * 严格判断输入为 End 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictEnd(node)) {
 *   // 在这个花括号内，node 的类型为 End
 * }
 * ```
 */
export declare function isStrictEnd(node: unknown): node is End;
/**
 * 严格判断输入为 IfStatement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictIfStatement(node)) {
 *   // 在这个花括号内，node 的类型为 IfStatement
 * }
 * ```
 */
export declare function isStrictIfStatement(node: unknown): node is IfStatement;
/**
 * 严格判断输入为 SwitchStatement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSwitchStatement(node)) {
 *   // 在这个花括号内，node 的类型为 SwitchStatement
 * }
 * ```
 */
export declare function isStrictSwitchStatement(node: unknown): node is SwitchStatement;
/**
 * 严格判断输入为 SwitchCase 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSwitchCase(node)) {
 *   // 在这个花括号内，node 的类型为 SwitchCase
 * }
 * ```
 */
export declare function isStrictSwitchCase(node: unknown): node is SwitchCase;
/**
 * 严格判断输入为 ForEachStatement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictForEachStatement(node)) {
 *   // 在这个花括号内，node 的类型为 ForEachStatement
 * }
 * ```
 */
export declare function isStrictForEachStatement(node: unknown): node is ForEachStatement;
/**
 * 严格判断输入为 WhileStatement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictWhileStatement(node)) {
 *   // 在这个花括号内，node 的类型为 WhileStatement
 * }
 * ```
 */
export declare function isStrictWhileStatement(node: unknown): node is WhileStatement;
/**
 * 严格判断输入为 Break 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBreak(node)) {
 *   // 在这个花括号内，node 的类型为 Break
 * }
 * ```
 */
export declare function isStrictBreak(node: unknown): node is Break;
/**
 * 严格判断输入为 Continue 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictContinue(node)) {
 *   // 在这个花括号内，node 的类型为 Continue
 * }
 * ```
 */
export declare function isStrictContinue(node: unknown): node is Continue;
/**
 * 严格判断输入为 Assignment 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAssignment(node)) {
 *   // 在这个花括号内，node 的类型为 Assignment
 * }
 * ```
 */
export declare function isStrictAssignment(node: unknown): node is Assignment;
/**
 * 严格判断输入为 BatchAssignment 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBatchAssignment(node)) {
 *   // 在这个花括号内，node 的类型为 BatchAssignment
 * }
 * ```
 */
export declare function isStrictBatchAssignment(node: unknown): node is BatchAssignment;
/**
 * 严格判断输入为 Comment 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictComment(node)) {
 *   // 在这个花括号内，node 的类型为 Comment
 * }
 * ```
 */
export declare function isStrictComment(node: unknown): node is Comment;
/**
 * 严格判断输入为 CallLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallLogic(node)) {
 *   // 在这个花括号内，node 的类型为 CallLogic
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallFunction(node)) {
 *   // 在这个花括号内，node 的类型为 CallFunction
 * }
 * ```
 */
export declare function isStrictCallFunction(node: unknown): node is CallFunction;
/**
 * 严格判断输入为 CallInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallInterface(node)) {
 *   // 在这个花括号内，node 的类型为 CallInterface
 * }
 * ```
 */
export declare function isStrictCallInterface(node: unknown): node is CallInterface;
/**
 * 严格判断输入为 CallMicroserviceInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallMicroserviceInterface(node)) {
 *   // 在这个花括号内，node 的类型为 CallMicroserviceInterface
 * }
 * ```
 */
export declare function isStrictCallMicroserviceInterface(node: unknown): node is CallMicroserviceInterface;
/**
 * 严格判断输入为 CallGatewayInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallGatewayInterface(node)) {
 *   // 在这个花括号内，node 的类型为 CallGatewayInterface
 * }
 * ```
 */
export declare function isStrictCallGatewayInterface(node: unknown): node is CallGatewayInterface;
/**
 * 严格判断输入为 Destination 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDestination(node)) {
 *   // 在这个花括号内，node 的类型为 Destination
 * }
 * ```
 */
export declare function isStrictDestination(node: unknown): node is Destination;
/**
 * 严格判断输入为 ExternalDestination 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictExternalDestination(node)) {
 *   // 在这个花括号内，node 的类型为 ExternalDestination
 * }
 * ```
 */
export declare function isStrictExternalDestination(node: unknown): node is ExternalDestination;
/**
 * 严格判断输入为 ValidationRule 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictValidationRule(node)) {
 *   // 在这个花括号内，node 的类型为 ValidationRule
 * }
 * ```
 */
export declare function isStrictValidationRule(node: unknown): node is ValidationRule;
/**
 * 严格判断输入为 ValidationLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictValidationLogic(node)) {
 *   // 在这个花括号内，node 的类型为 ValidationLogic
 * }
 * ```
 */
export declare function isStrictValidationLogic(node: unknown): node is ValidationLogic;
/**
 * 严格判断输入为 Argument 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictArgument(node)) {
 *   // 在这个花括号内，node 的类型为 Argument
 * }
 * ```
 */
export declare function isStrictArgument(node: unknown): node is Argument;
/**
 * 严格判断输入为 Anchor 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAnchor(node)) {
 *   // 在这个花括号内，node 的类型为 Anchor
 * }
 * ```
 */
export declare function isStrictAnchor(node: unknown): node is Anchor;
/**
 * 严格判断输入为 JSBlock 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictJSBlock(node)) {
 *   // 在这个花括号内，node 的类型为 JSBlock
 * }
 * ```
 */
export declare function isStrictJSBlock(node: unknown): node is JSBlock;
/**
 * 严格判断输入为 JavaLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictJavaLogic(node)) {
 *   // 在这个花括号内，node 的类型为 JavaLogic
 * }
 * ```
 */
export declare function isStrictJavaLogic(node: unknown): node is JavaLogic;
/**
 * 严格判断输入为 Block 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBlock(node)) {
 *   // 在这个花括号内，node 的类型为 Block
 * }
 * ```
 */
export declare function isStrictBlock(node: unknown): node is Block;
/**
 * 严格判断输入为 Identifier 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictIdentifier(node)) {
 *   // 在这个花括号内，node 的类型为 Identifier
 * }
 * ```
 */
export declare function isStrictIdentifier(node: unknown): node is Identifier;
/**
 * 严格判断输入为 NullLiteral 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNullLiteral(node)) {
 *   // 在这个花括号内，node 的类型为 NullLiteral
 * }
 * ```
 */
export declare function isStrictNullLiteral(node: unknown): node is NullLiteral;
/**
 * 严格判断输入为 BooleanLiteral 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBooleanLiteral(node)) {
 *   // 在这个花括号内，node 的类型为 BooleanLiteral
 * }
 * ```
 */
export declare function isStrictBooleanLiteral(node: unknown): node is BooleanLiteral;
/**
 * 严格判断输入为 StringLiteral 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStringLiteral(node)) {
 *   // 在这个花括号内，node 的类型为 StringLiteral
 * }
 * ```
 */
export declare function isStrictStringLiteral(node: unknown): node is StringLiteral;
/**
 * 严格判断输入为 StringInterpolation 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStringInterpolation(node)) {
 *   // 在这个花括号内，node 的类型为 StringInterpolation
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNumericLiteral(node)) {
 *   // 在这个花括号内，node 的类型为 NumericLiteral
 * }
 * ```
 */
export declare function isStrictNumericLiteral(node: unknown): node is NumericLiteral;
/**
 * 严格判断输入为 BinaryExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictBinaryExpression(node)) {
 *   // 在这个花括号内，node 的类型为 BinaryExpression
 * }
 * ```
 */
export declare function isStrictBinaryExpression(node: unknown): node is BinaryExpression;
/**
 * 严格判断输入为 VariadicExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictVariadicExpression(node)) {
 *   // 在这个花括号内，node 的类型为 VariadicExpression
 * }
 * ```
 */
export declare function isStrictVariadicExpression(node: unknown): node is VariadicExpression;
/**
 * 严格判断输入为 MatchCase 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMatchCase(node)) {
 *   // 在这个花括号内，node 的类型为 MatchCase
 * }
 * ```
 */
export declare function isStrictMatchCase(node: unknown): node is MatchCase;
/**
 * 严格判断输入为 Match 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMatch(node)) {
 *   // 在这个花括号内，node 的类型为 Match
 * }
 * ```
 */
export declare function isStrictMatch(node: unknown): node is Match;
/**
 * 严格判断输入为 UnaryExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictUnaryExpression(node)) {
 *   // 在这个花括号内，node 的类型为 UnaryExpression
 * }
 * ```
 */
export declare function isStrictUnaryExpression(node: unknown): node is UnaryExpression;
/**
 * 严格判断输入为 MemberExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMemberExpression(node)) {
 *   // 在这个花括号内，node 的类型为 MemberExpression
 * }
 * ```
 */
export declare function isStrictMemberExpression(node: unknown): node is MemberExpression;
/**
 * 严格判断输入为 Unparsed 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictUnparsed(node)) {
 *   // 在这个花括号内，node 的类型为 Unparsed
 * }
 * ```
 */
export declare function isStrictUnparsed(node: unknown): node is Unparsed;
/**
 * 严格判断输入为 New 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNew(node)) {
 *   // 在这个花括号内，node 的类型为 New
 * }
 * ```
 */
export declare function isStrictNew(node: unknown): node is New;
/**
 * 严格判断输入为 NewComposite 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNewComposite(node)) {
 *   // 在这个花括号内，node 的类型为 NewComposite
 * }
 * ```
 */
export declare function isStrictNewComposite(node: unknown): node is NewComposite;
/**
 * 严格判断输入为 NewStructure 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNewStructure(node)) {
 *   // 在这个花括号内，node 的类型为 NewStructure
 * }
 * ```
 */
export declare function isStrictNewStructure(node: unknown): node is NewStructure;
/**
 * 严格判断输入为 NewList 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNewList(node)) {
 *   // 在这个花括号内，node 的类型为 NewList
 * }
 * ```
 */
export declare function isStrictNewList(node: unknown): node is NewList;
/**
 * 严格判断输入为 NewMap 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNewMap(node)) {
 *   // 在这个花括号内，node 的类型为 NewMap
 * }
 * ```
 */
export declare function isStrictNewMap(node: unknown): node is NewMap;
/**
 * 严格判断输入为 NewRegex 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictNewRegex(node)) {
 *   // 在这个花括号内，node 的类型为 NewRegex
 * }
 * ```
 */
export declare function isStrictNewRegex(node: unknown): node is NewRegex;
/**
 * 严格判断输入为 Paginate 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictPaginate(node)) {
 *   // 在这个花括号内，node 的类型为 Paginate
 * }
 * ```
 */
export declare function isStrictPaginate(node: unknown): node is Paginate;
/**
 * 严格判断输入为 CallQueryComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型为 CallQueryComponent
 * }
 * ```
 */
export declare function isStrictCallQueryComponent(node: unknown): node is CallQueryComponent;
/**
 * 严格判断输入为 QuerySelectExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQuerySelectExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QuerySelectExpression
 * }
 * ```
 */
export declare function isStrictQuerySelectExpression(node: unknown): node is QuerySelectExpression;
/**
 * 严格判断输入为 QueryFromExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryFromExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryFromExpression
 * }
 * ```
 */
export declare function isStrictQueryFromExpression(node: unknown): node is QueryFromExpression;
/**
 * 严格判断输入为 QueryJoinExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryJoinExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryJoinExpression
 * }
 * ```
 */
export declare function isStrictQueryJoinExpression(node: unknown): node is QueryJoinExpression;
/**
 * 严格判断输入为 QueryFieldExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryFieldExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryFieldExpression
 * }
 * ```
 */
export declare function isStrictQueryFieldExpression(node: unknown): node is QueryFieldExpression;
/**
 * 严格判断输入为 QueryAggregateExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryAggregateExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryAggregateExpression
 * }
 * ```
 */
export declare function isStrictQueryAggregateExpression(node: unknown): node is QueryAggregateExpression;
/**
 * 严格判断输入为 QueryOrderByExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryOrderByExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryOrderByExpression
 * }
 * ```
 */
export declare function isStrictQueryOrderByExpression(node: unknown): node is QueryOrderByExpression;
/**
 * 严格判断输入为 QueryGroupByExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryGroupByExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryGroupByExpression
 * }
 * ```
 */
export declare function isStrictQueryGroupByExpression(node: unknown): node is QueryGroupByExpression;
/**
 * 严格判断输入为 QueryLimitExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictQueryLimitExpression(node)) {
 *   // 在这个花括号内，node 的类型为 QueryLimitExpression
 * }
 * ```
 */
export declare function isStrictQueryLimitExpression(node: unknown): node is QueryLimitExpression;
/**
 * 严格判断输入为 SqlQueryComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSqlQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型为 SqlQueryComponent
 * }
 * ```
 */
export declare function isStrictSqlQueryComponent(node: unknown): node is SqlQueryComponent;
/**
 * 严格判断输入为 OqlQueryComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictOqlQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型为 OqlQueryComponent
 * }
 * ```
 */
export declare function isStrictOqlQueryComponent(node: unknown): node is OqlQueryComponent;
/**
 * 严格判断输入为 Process 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcess(node)) {
 *   // 在这个花括号内，node 的类型为 Process
 * }
 * ```
 */
export declare function isStrictProcess(node: unknown): node is Process;
/**
 * 严格判断输入为 ProcessElement 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessElement(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessElement
 * }
 * ```
 */
export declare function isStrictProcessElement(node: unknown): node is ProcessElement;
/**
 * 严格判断输入为 ProcessComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessComponent(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessComponent
 * }
 * ```
 */
export declare function isStrictProcessComponent(node: unknown): node is ProcessComponent;
/**
 * 严格判断输入为 SequentialPolicy 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSequentialPolicy(node)) {
 *   // 在这个花括号内，node 的类型为 SequentialPolicy
 * }
 * ```
 */
export declare function isStrictSequentialPolicy(node: unknown): node is SequentialPolicy;
/**
 * 严格判断输入为 CountersignPolicy 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCountersignPolicy(node)) {
 *   // 在这个花括号内，node 的类型为 CountersignPolicy
 * }
 * ```
 */
export declare function isStrictCountersignPolicy(node: unknown): node is CountersignPolicy;
/**
 * 严格判断输入为 ProcessOutcome 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessOutcome(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessOutcome
 * }
 * ```
 */
export declare function isStrictProcessOutcome(node: unknown): node is ProcessOutcome;
/**
 * 严格判断输入为 Assignee 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAssignee(node)) {
 *   // 在这个花括号内，node 的类型为 Assignee
 * }
 * ```
 */
export declare function isStrictAssignee(node: unknown): node is Assignee;
/**
 * 严格判断输入为 ProcessOutcomes 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessOutcomes(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessOutcomes
 * }
 * ```
 */
export declare function isStrictProcessOutcomes(node: unknown): node is ProcessOutcomes;
/**
 * 严格判断输入为 Role 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictRole(node)) {
 *   // 在这个花括号内，node 的类型为 Role
 * }
 * ```
 */
export declare function isStrictRole(node: unknown): node is Role;
/**
 * 严格判断输入为 Configuration 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConfiguration(node)) {
 *   // 在这个花括号内，node 的类型为 Configuration
 * }
 * ```
 */
export declare function isStrictConfiguration(node: unknown): node is Configuration;
/**
 * 严格判断输入为 ConfigGroup 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConfigGroup(node)) {
 *   // 在这个花括号内，node 的类型为 ConfigGroup
 * }
 * ```
 */
export declare function isStrictConfigGroup(node: unknown): node is ConfigGroup;
/**
 * 严格判断输入为 ConfigProperty 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConfigProperty(node)) {
 *   // 在这个花括号内，node 的类型为 ConfigProperty
 * }
 * ```
 */
export declare function isStrictConfigProperty(node: unknown): node is ConfigProperty;
/**
 * 严格判断输入为 ConfigPropertyValue 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConfigPropertyValue(node)) {
 *   // 在这个花括号内，node 的类型为 ConfigPropertyValue
 * }
 * ```
 */
export declare function isStrictConfigPropertyValue(node: unknown): node is ConfigPropertyValue;
/**
 * 严格判断输入为 I18nInfo 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictI18nInfo(node)) {
 *   // 在这个花括号内，node 的类型为 I18nInfo
 * }
 * ```
 */
export declare function isStrictI18nInfo(node: unknown): node is I18nInfo;
/**
 * 严格判断输入为 StyleInfo 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictStyleInfo(node)) {
 *   // 在这个花括号内，node 的类型为 StyleInfo
 * }
 * ```
 */
export declare function isStrictStyleInfo(node: unknown): node is StyleInfo;
/**
 * 严格判断输入为 CompletionProperty 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCompletionProperty(node)) {
 *   // 在这个花括号内，node 的类型为 CompletionProperty
 * }
 * ```
 */
export declare function isStrictCompletionProperty(node: unknown): node is CompletionProperty;
/**
 * 严格判断输入为 UseComponent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictUseComponent(node)) {
 *   // 在这个花括号内，node 的类型为 UseComponent
 * }
 * ```
 */
export declare function isStrictUseComponent(node: unknown): node is UseComponent;
/**
 * 严格判断输入为 Point 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictPoint(node)) {
 *   // 在这个花括号内，node 的类型为 Point
 * }
 * ```
 */
export declare function isStrictPoint(node: unknown): node is Point;
/**
 * 严格判断输入为 Rect 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictRect(node)) {
 *   // 在这个花括号内，node 的类型为 Rect
 * }
 * ```
 */
export declare function isStrictRect(node: unknown): node is Rect;
/**
 * 严格判断输入为 SelectMembers 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSelectMembers(node)) {
 *   // 在这个花括号内，node 的类型为 SelectMembers
 * }
 * ```
 */
export declare function isStrictSelectMembers(node: unknown): node is SelectMembers;
/**
 * 严格判断输入为 AssignmentLine 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAssignmentLine(node)) {
 *   // 在这个花括号内，node 的类型为 AssignmentLine
 * }
 * ```
 */
export declare function isStrictAssignmentLine(node: unknown): node is AssignmentLine;
/**
 * 严格判断输入为 FrontendLibrary 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFrontendLibrary(node)) {
 *   // 在这个花括号内，node 的类型为 FrontendLibrary
 * }
 * ```
 */
export declare function isStrictFrontendLibrary(node: unknown): node is FrontendLibrary;
/**
 * 严格判断输入为 ViewBlock 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictViewBlock(node)) {
 *   // 在这个花括号内，node 的类型为 ViewBlock
 * }
 * ```
 */
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 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAuthInterface(node)) {
 *   // 在这个花括号内，node 的类型为 AuthInterface
 * }
 * ```
 */
export declare function isStrictAuthInterface(node: unknown): node is AuthInterface;
/**
 * 严格判断输入为 CallAuthInterface 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallAuthInterface(node)) {
 *   // 在这个花括号内，node 的类型为 CallAuthInterface
 * }
 * ```
 */
export declare function isStrictCallAuthInterface(node: unknown): node is CallAuthInterface;
/**
 * 严格判断输入为 MsgTriggerEvent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMsgTriggerEvent(node)) {
 *   // 在这个花括号内，node 的类型为 MsgTriggerEvent
 * }
 * ```
 */
export declare function isStrictMsgTriggerEvent(node: unknown): node is MsgTriggerEvent;
/**
 * 严格判断输入为 InterfaceTriggerEvent 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictInterfaceTriggerEvent(node)) {
 *   // 在这个花括号内，node 的类型为 InterfaceTriggerEvent
 * }
 * ```
 */
export declare function isStrictInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent;
/**
 * 严格判断输入为 ConnectorTrigger 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnectorTrigger(node)) {
 *   // 在这个花括号内，node 的类型为 ConnectorTrigger
 * }
 * ```
 */
export declare function isStrictConnectorTrigger(node: unknown): node is ConnectorTrigger;
/**
 * 严格判断输入为 TriggerLauncher 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型为 TriggerLauncher
 * }
 * ```
 */
export declare function isStrictTriggerLauncher(node: unknown): node is TriggerLauncher;
/**
 * 严格判断输入为 ConnectorTriggerLauncher 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnectorTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型为 ConnectorTriggerLauncher
 * }
 * ```
 */
export declare function isStrictConnectorTriggerLauncher(node: unknown): node is ConnectorTriggerLauncher;
/**
 * 严格判断输入为 MsgTriggerLauncher 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictMsgTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型为 MsgTriggerLauncher
 * }
 * ```
 */
export declare function isStrictMsgTriggerLauncher(node: unknown): node is MsgTriggerLauncher;
/**
 * 严格判断输入为 Dependency 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDependency(node)) {
 *   // 在这个花括号内，node 的类型为 Dependency
 * }
 * ```
 */
export declare function isStrictDependency(node: unknown): node is Dependency;
/**
 * 严格判断输入为 Connector 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnector(node)) {
 *   // 在这个花括号内，node 的类型为 Connector
 * }
 * ```
 */
export declare function isStrictConnector(node: unknown): node is Connector;
/**
 * 严格判断输入为 CallConnector 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCallConnector(node)) {
 *   // 在这个花括号内，node 的类型为 CallConnector
 * }
 * ```
 */
export declare function isStrictCallConnector(node: unknown): node is CallConnector;
/**
 * 严格判断输入为 Connection 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnection(node)) {
 *   // 在这个花括号内，node 的类型为 Connection
 * }
 * ```
 */
export declare function isStrictConnection(node: unknown): node is Connection;
/**
 * 严格判断输入为 ConnectorLogic 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictConnectorLogic(node)) {
 *   // 在这个花括号内，node 的类型为 ConnectorLogic
 * }
 * ```
 */
export declare function isStrictConnectorLogic(node: unknown): node is ConnectorLogic;
/**
 * 严格判断输入为 ProcessV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessV2(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessV2
 * }
 * ```
 */
export declare function isStrictProcessV2(node: unknown): node is ProcessV2;
/**
 * 严格判断输入为 ProcessDefinitionV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessDefinitionV2(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessDefinitionV2
 * }
 * ```
 */
export declare function isStrictProcessDefinitionV2(node: unknown): node is ProcessDefinitionV2;
/**
 * 严格判断输入为 HistoryProcessV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictHistoryProcessV2(node)) {
 *   // 在这个花括号内，node 的类型为 HistoryProcessV2
 * }
 * ```
 */
export declare function isStrictHistoryProcessV2(node: unknown): node is HistoryProcessV2;
/**
 * 严格判断输入为 ProcessBindV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessBindV2(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessBindV2
 * }
 * ```
 */
export declare function isStrictProcessBindV2(node: unknown): node is ProcessBindV2;
/**
 * 严格判断输入为 FieldPermissionV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFieldPermissionV2(node)) {
 *   // 在这个花括号内，node 的类型为 FieldPermissionV2
 * }
 * ```
 */
export declare function isStrictFieldPermissionV2(node: unknown): node is FieldPermissionV2;
/**
 * 严格判断输入为 ProcessElementV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictProcessElementV2(node)) {
 *   // 在这个花括号内，node 的类型为 ProcessElementV2
 * }
 * ```
 */
export declare function isStrictProcessElementV2(node: unknown): node is ProcessElementV2;
/**
 * 严格判断输入为 SubProcessDataMappingRule 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSubProcessDataMappingRule(node)) {
 *   // 在这个花括号内，node 的类型为 SubProcessDataMappingRule
 * }
 * ```
 */
export declare function isStrictSubProcessDataMappingRule(node: unknown): node is SubProcessDataMappingRule;
/**
 * 严格判断输入为 OperatePermissionV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictOperatePermissionV2(node)) {
 *   // 在这个花括号内，node 的类型为 OperatePermissionV2
 * }
 * ```
 */
export declare function isStrictOperatePermissionV2(node: unknown): node is OperatePermissionV2;
/**
 * 严格判断输入为 AssigneeV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAssigneeV2(node)) {
 *   // 在这个花括号内，node 的类型为 AssigneeV2
 * }
 * ```
 */
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;
/**
 * 严格判断输入为 UserAssignees 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictUserAssignees(node)) {
 *   // 在这个花括号内，node 的类型为 UserAssignees
 * }
 * ```
 */
export declare function isStrictUserAssignees(node: unknown): node is UserAssignees;
/**
 * 严格判断输入为 RoleAssignees 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictRoleAssignees(node)) {
 *   // 在这个花括号内，node 的类型为 RoleAssignees
 * }
 * ```
 */
export declare function isStrictRoleAssignees(node: unknown): node is RoleAssignees;
/**
 * 严格判断输入为 DepartmentAssignees 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictDepartmentAssignees(node)) {
 *   // 在这个花括号内，node 的类型为 DepartmentAssignees
 * }
 * ```
 */
export declare function isStrictDepartmentAssignees(node: unknown): node is DepartmentAssignees;
/**
 * 严格判断输入为 FlowConditionV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictFlowConditionV2(node)) {
 *   // 在这个花括号内，node 的类型为 FlowConditionV2
 * }
 * ```
 */
export declare function isStrictFlowConditionV2(node: unknown): node is FlowConditionV2;
/**
 * 严格判断输入为 SequentialPolicyV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictSequentialPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型为 SequentialPolicyV2
 * }
 * ```
 */
export declare function isStrictSequentialPolicyV2(node: unknown): node is SequentialPolicyV2;
/**
 * 严格判断输入为 CountersignPolicyV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictCountersignPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型为 CountersignPolicyV2
 * }
 * ```
 */
export declare function isStrictCountersignPolicyV2(node: unknown): node is CountersignPolicyV2;
/**
 * 严格判断输入为 OrSignPolicyV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictOrSignPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型为 OrSignPolicyV2
 * }
 * ```
 */
export declare function isStrictOrSignPolicyV2(node: unknown): node is OrSignPolicyV2;
/**
 * 严格判断输入为 AutoApproveUnmannedV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAutoApproveUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型为 AutoApproveUnmannedV2
 * }
 * ```
 */
export declare function isStrictAutoApproveUnmannedV2(node: unknown): node is AutoApproveUnmannedV2;
/**
 * 严格判断输入为 AutoRejectUnmannedV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictAutoRejectUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型为 AutoRejectUnmannedV2
 * }
 * ```
 */
export declare function isStrictAutoRejectUnmannedV2(node: unknown): node is AutoRejectUnmannedV2;
/**
 * 严格判断输入为 ReassignUnmannedV2 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictReassignUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型为 ReassignUnmannedV2
 * }
 * ```
 */
export declare function isStrictReassignUnmannedV2(node: unknown): node is ReassignUnmannedV2;
/**
 * 判断输入为 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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，App 节点没有继承类，此判断等价于`isStrictApp`
 * @example
 * ```ts
 * if (isApp(node)) {
 *   // 在这个花括号内，node 的类型是 App 或者 App 继承类型
 * }
 * ```
 */
export declare function isApp(node: unknown): node is App;
/**
 * 判断输入为 Module 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isModule(node)) {
 *   // 在这个花括号内，node 的类型是 Module 或者 Module 继承类型
 * }
 * ```
 */
export declare function isModule(node: unknown): node is types.ModuleNode;
/**
 * 判断输入为 Namespace 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Namespace 节点没有继承类，此判断等价于`isStrictNamespace`
 * @example
 * ```ts
 * if (isNamespace(node)) {
 *   // 在这个花括号内，node 的类型是 Namespace 或者 Namespace 继承类型
 * }
 * ```
 */
export declare function isNamespace(node: unknown): node is Namespace;
/**
 * 判断输入为 Directory 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Directory 节点没有继承类，此判断等价于`isStrictDirectory`
 * @example
 * ```ts
 * if (isDirectory(node)) {
 *   // 在这个花括号内，node 的类型是 Directory 或者 Directory 继承类型
 * }
 * ```
 */
export declare function isDirectory(node: unknown): node is Directory;
/**
 * 判断输入为 ReferredDefinition 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ReferredDefinition 节点没有继承类，此判断等价于`isStrictReferredDefinition`
 * @example
 * ```ts
 * if (isReferredDefinition(node)) {
 *   // 在这个花括号内，node 的类型是 ReferredDefinition 或者 ReferredDefinition 继承类型
 * }
 * ```
 */
export declare function isReferredDefinition(node: unknown): node is ReferredDefinition;
/**
 * 判断输入为 FrontendType 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，FrontendType 节点没有继承类，此判断等价于`isStrictFrontendType`
 * @example
 * ```ts
 * if (isFrontendType(node)) {
 *   // 在这个花括号内，node 的类型是 FrontendType 或者 FrontendType 继承类型
 * }
 * ```
 */
export declare function isFrontendType(node: unknown): node is FrontendType;
/**
 * 判断输入为 Frontend 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Frontend 节点没有继承类，此判断等价于`isStrictFrontend`
 * @example
 * ```ts
 * if (isFrontend(node)) {
 *   // 在这个花括号内，node 的类型是 Frontend 或者 Frontend 继承类型
 * }
 * ```
 */
export declare function isFrontend(node: unknown): node is Frontend;
/**
 * 判断输入为 Backend 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Backend 节点没有继承类，此判断等价于`isStrictBackend`
 * @example
 * ```ts
 * if (isBackend(node)) {
 *   // 在这个花括号内，node 的类型是 Backend 或者 Backend 继承类型
 * }
 * ```
 */
export declare function isBackend(node: unknown): node is Backend;
/**
 * 判断输入为 Integration 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Integration 节点没有继承类，此判断等价于`isStrictIntegration`
 * @example
 * ```ts
 * if (isIntegration(node)) {
 *   // 在这个花括号内，node 的类型是 Integration 或者 Integration 继承类型
 * }
 * ```
 */
export declare function isIntegration(node: unknown): node is Integration;
/**
 * 判断输入为 MicroApp 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MicroApp 节点没有继承类，此判断等价于`isStrictMicroApp`
 * @example
 * ```ts
 * if (isMicroApp(node)) {
 *   // 在这个花括号内，node 的类型是 MicroApp 或者 MicroApp 继承类型
 * }
 * ```
 */
export declare function isMicroApp(node: unknown): node is MicroApp;
/**
 * 判断输入为 TypeAnnotation 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，TypeAnnotation 节点没有继承类，此判断等价于`isStrictTypeAnnotation`
 * @example
 * ```ts
 * if (isTypeAnnotation(node)) {
 *   // 在这个花括号内，node 的类型是 TypeAnnotation 或者 TypeAnnotation 继承类型
 * }
 * ```
 */
export declare function isTypeAnnotation(node: unknown): node is TypeAnnotation;
/**
 * 判断输入为 DatabaseTypeAnnotation 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，DatabaseTypeAnnotation 节点没有继承类，此判断等价于`isStrictDatabaseTypeAnnotation`
 * @example
 * ```ts
 * if (isDatabaseTypeAnnotation(node)) {
 *   // 在这个花括号内，node 的类型是 DatabaseTypeAnnotation 或者 DatabaseTypeAnnotation 继承类型
 * }
 * ```
 */
export declare function isDatabaseTypeAnnotation(node: unknown): node is DatabaseTypeAnnotation;
/**
 * 判断输入为 TypeParam 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，TypeParam 节点没有继承类，此判断等价于`isStrictTypeParam`
 * @example
 * ```ts
 * if (isTypeParam(node)) {
 *   // 在这个花括号内，node 的类型是 TypeParam 或者 TypeParam 继承类型
 * }
 * ```
 */
export declare function isTypeParam(node: unknown): node is TypeParam;
/**
 * 判断输入为 Structure 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Structure 节点没有继承类，此判断等价于`isStrictStructure`
 * @example
 * ```ts
 * if (isStructure(node)) {
 *   // 在这个花括号内，node 的类型是 Structure 或者 Structure 继承类型
 * }
 * ```
 */
export declare function isStructure(node: unknown): node is Structure;
/**
 * 判断输入为 StructureProperty 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，StructureProperty 节点没有继承类，此判断等价于`isStrictStructureProperty`
 * @example
 * ```ts
 * if (isStructureProperty(node)) {
 *   // 在这个花括号内，node 的类型是 StructureProperty 或者 StructureProperty 继承类型
 * }
 * ```
 */
export declare function isStructureProperty(node: unknown): node is StructureProperty;
/**
 * 判断输入为 Enum 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Enum 节点没有继承类，此判断等价于`isStrictEnum`
 * @example
 * ```ts
 * if (isEnum(node)) {
 *   // 在这个花括号内，node 的类型是 Enum 或者 Enum 继承类型
 * }
 * ```
 */
export declare function isEnum(node: unknown): node is Enum;
/**
 * 判断输入为 EnumItem 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，EnumItem 节点没有继承类，此判断等价于`isStrictEnumItem`
 * @example
 * ```ts
 * if (isEnumItem(node)) {
 *   // 在这个花括号内，node 的类型是 EnumItem 或者 EnumItem 继承类型
 * }
 * ```
 */
export declare function isEnumItem(node: unknown): node is EnumItem;
/**
 * 判断输入为 DataSource 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，DataSource 节点没有继承类，此判断等价于`isStrictDataSource`
 * @example
 * ```ts
 * if (isDataSource(node)) {
 *   // 在这个花括号内，node 的类型是 DataSource 或者 DataSource 继承类型
 * }
 * ```
 */
export declare function isDataSource(node: unknown): node is DataSource;
/**
 * 判断输入为 Entity 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Entity 节点没有继承类，此判断等价于`isStrictEntity`
 * @example
 * ```ts
 * if (isEntity(node)) {
 *   // 在这个花括号内，node 的类型是 Entity 或者 Entity 继承类型
 * }
 * ```
 */
export declare function isEntity(node: unknown): node is Entity;
/**
 * 判断输入为 EntityProperty 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，EntityProperty 节点没有继承类，此判断等价于`isStrictEntityProperty`
 * @example
 * ```ts
 * if (isEntityProperty(node)) {
 *   // 在这个花括号内，node 的类型是 EntityProperty 或者 EntityProperty 继承类型
 * }
 * ```
 */
export declare function isEntityProperty(node: unknown): node is EntityProperty;
/**
 * 判断输入为 EntityIndex 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，EntityIndex 节点没有继承类，此判断等价于`isStrictEntityIndex`
 * @example
 * ```ts
 * if (isEntityIndex(node)) {
 *   // 在这个花括号内，node 的类型是 EntityIndex 或者 EntityIndex 继承类型
 * }
 * ```
 */
export declare function isEntityIndex(node: unknown): node is EntityIndex;
/**
 * 判断输入为 MetadataType 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MetadataType 节点没有继承类，此判断等价于`isStrictMetadataType`
 * @example
 * ```ts
 * if (isMetadataType(node)) {
 *   // 在这个花括号内，node 的类型是 MetadataType 或者 MetadataType 继承类型
 * }
 * ```
 */
export declare function isMetadataType(node: unknown): node is MetadataType;
/**
 * 判断输入为 View 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，View 节点没有继承类，此判断等价于`isStrictView`
 * @example
 * ```ts
 * if (isView(node)) {
 *   // 在这个花括号内，node 的类型是 View 或者 View 继承类型
 * }
 * ```
 */
export declare function isView(node: unknown): node is View;
/**
 * 判断输入为 ViewElement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ViewElement 节点没有继承类，此判断等价于`isStrictViewElement`
 * @example
 * ```ts
 * if (isViewElement(node)) {
 *   // 在这个花括号内，node 的类型是 ViewElement 或者 ViewElement 继承类型
 * }
 * ```
 */
export declare function isViewElement(node: unknown): node is ViewElement;
/**
 * 判断输入为 BindAttribute 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BindAttribute 节点没有继承类，此判断等价于`isStrictBindAttribute`
 * @example
 * ```ts
 * if (isBindAttribute(node)) {
 *   // 在这个花括号内，node 的类型是 BindAttribute 或者 BindAttribute 继承类型
 * }
 * ```
 */
export declare function isBindAttribute(node: unknown): node is BindAttribute;
/**
 * 判断输入为 BindDirective 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BindDirective 节点没有继承类，此判断等价于`isStrictBindDirective`
 * @example
 * ```ts
 * if (isBindDirective(node)) {
 *   // 在这个花括号内，node 的类型是 BindDirective 或者 BindDirective 继承类型
 * }
 * ```
 */
export declare function isBindDirective(node: unknown): node is BindDirective;
/**
 * 判断输入为 BindEvent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BindEvent 节点没有继承类，此判断等价于`isStrictBindEvent`
 * @example
 * ```ts
 * if (isBindEvent(node)) {
 *   // 在这个花括号内，node 的类型是 BindEvent 或者 BindEvent 继承类型
 * }
 * ```
 */
export declare function isBindEvent(node: unknown): node is BindEvent;
/**
 * 判断输入为 BindStyle 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BindStyle 节点没有继承类，此判断等价于`isStrictBindStyle`
 * @example
 * ```ts
 * if (isBindStyle(node)) {
 *   // 在这个花括号内，node 的类型是 BindStyle 或者 BindStyle 继承类型
 * }
 * ```
 */
export declare function isBindStyle(node: unknown): node is BindStyle;
/**
 * 判断输入为 ThemeVariable 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ThemeVariable 节点没有继承类，此判断等价于`isStrictThemeVariable`
 * @example
 * ```ts
 * if (isThemeVariable(node)) {
 *   // 在这个花括号内，node 的类型是 ThemeVariable 或者 ThemeVariable 继承类型
 * }
 * ```
 */
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;
/**
 * 判断输入为 CustomSetter 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CustomSetter 节点没有继承类，此判断等价于`isStrictCustomSetter`
 * @example
 * ```ts
 * if (isCustomSetter(node)) {
 *   // 在这个花括号内，node 的类型是 CustomSetter 或者 CustomSetter 继承类型
 * }
 * ```
 */
export declare function isCustomSetter(node: unknown): node is CustomSetter;
/**
 * 判断输入为 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;
/**
 * 判断输入为 PropertyTransformSetter 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，PropertyTransformSetter 节点没有继承类，此判断等价于`isStrictPropertyTransformSetter`
 * @example
 * ```ts
 * if (isPropertyTransformSetter(node)) {
 *   // 在这个花括号内，node 的类型是 PropertyTransformSetter 或者 PropertyTransformSetter 继承类型
 * }
 * ```
 */
export declare function isPropertyTransformSetter(node: unknown): node is PropertyTransformSetter;
/**
 * 判断输入为 AnonymousFunctionSetter 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AnonymousFunctionSetter 节点没有继承类，此判断等价于`isStrictAnonymousFunctionSetter`
 * @example
 * ```ts
 * if (isAnonymousFunctionSetter(node)) {
 *   // 在这个花括号内，node 的类型是 AnonymousFunctionSetter 或者 AnonymousFunctionSetter 继承类型
 * }
 * ```
 */
export declare function isAnonymousFunctionSetter(node: unknown): node is AnonymousFunctionSetter;
/**
 * 判断输入为 DataSourceSetter 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，DataSourceSetter 节点没有继承类，此判断等价于`isStrictDataSourceSetter`
 * @example
 * ```ts
 * if (isDataSourceSetter(node)) {
 *   // 在这个花括号内，node 的类型是 DataSourceSetter 或者 DataSourceSetter 继承类型
 * }
 * ```
 */
export declare function isDataSourceSetter(node: unknown): node is DataSourceSetter;
/**
 * 判断输入为 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;
/**
 * 判断输入为 CSSRule 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CSSRule 节点没有继承类，此判断等价于`isStrictCSSRule`
 * @example
 * ```ts
 * if (isCSSRule(node)) {
 *   // 在这个花括号内，node 的类型是 CSSRule 或者 CSSRule 继承类型
 * }
 * ```
 */
export declare function isCSSRule(node: unknown): node is CSSRule;
/**
 * 判断输入为 Theme 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Theme 节点没有继承类，此判断等价于`isStrictTheme`
 * @example
 * ```ts
 * if (isTheme(node)) {
 *   // 在这个花括号内，node 的类型是 Theme 或者 Theme 继承类型
 * }
 * ```
 */
export declare function isTheme(node: unknown): node is Theme;
/**
 * 判断输入为 Slot 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Slot 节点没有继承类，此判断等价于`isStrictSlot`
 * @example
 * ```ts
 * if (isSlot(node)) {
 *   // 在这个花括号内，node 的类型是 Slot 或者 Slot 继承类型
 * }
 * ```
 */
export declare function isSlot(node: unknown): node is Slot;
/**
 * 判断输入为 ViewComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ViewComponent 节点没有继承类，此判断等价于`isStrictViewComponent`
 * @example
 * ```ts
 * if (isViewComponent(node)) {
 *   // 在这个花括号内，node 的类型是 ViewComponent 或者 ViewComponent 继承类型
 * }
 * ```
 */
export declare function isViewComponent(node: unknown): node is ViewComponent;
/**
 * 判断输入为 Logic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isLogic(node)) {
 *   // 在这个花括号内，node 的类型是 Logic 或者 Logic 继承类型
 * }
 * ```
 */
export declare function isLogic(node: unknown): node is types.LogicNode;
/**
 * 判断输入为 SharedScope 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isSharedScope(node)) {
 *   // 在这个花括号内，node 的类型是 SharedScope 或者 SharedScope 继承类型
 * }
 * ```
 */
export declare function isSharedScope(node: unknown): node is types.SharedScopeNode;
/**
 * 判断输入为 PermissionForSharedScope 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，PermissionForSharedScope 节点没有继承类，此判断等价于`isStrictPermissionForSharedScope`
 * @example
 * ```ts
 * if (isPermissionForSharedScope(node)) {
 *   // 在这个花括号内，node 的类型是 PermissionForSharedScope 或者 PermissionForSharedScope 继承类型
 * }
 * ```
 */
export declare function isPermissionForSharedScope(node: unknown): node is PermissionForSharedScope;
/**
 * 判断输入为 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`
 * @example
 * ```ts
 * if (isAuthLogicForCallInterface(node)) {
 *   // 在这个花括号内，node 的类型是 AuthLogicForCallInterface 或者 AuthLogicForCallInterface 继承类型
 * }
 * ```
 */
export declare function isAuthLogicForCallInterface(node: unknown): node is AuthLogicForCallInterface;
/**
 * 判断输入为 OverriddenLogic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，OverriddenLogic 节点没有继承类，此判断等价于`isStrictOverriddenLogic`
 * @example
 * ```ts
 * if (isOverriddenLogic(node)) {
 *   // 在这个花括号内，node 的类型是 OverriddenLogic 或者 OverriddenLogic 继承类型
 * }
 * ```
 */
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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isAbstractInterface(node)) {
 *   // 在这个花括号内，node 的类型是 AbstractInterface 或者 AbstractInterface 继承类型
 * }
 * ```
 */
export declare function isAbstractInterface(node: unknown): node is types.AbstractInterfaceNode;
/**
 * 判断输入为 Param 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isParam(node)) {
 *   // 在这个花括号内，node 的类型是 Param 或者 Param 继承类型
 * }
 * ```
 */
export declare function isParam(node: unknown): node is types.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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Return 节点没有继承类，此判断等价于`isStrictReturn`
 * @example
 * ```ts
 * if (isReturn(node)) {
 *   // 在这个花括号内，node 的类型是 Return 或者 Return 继承类型
 * }
 * ```
 */
export declare function isReturn(node: unknown): node is Return;
/**
 * 判断输入为 Variable 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isVariable(node)) {
 *   // 在这个花括号内，node 的类型是 Variable 或者 Variable 继承类型
 * }
 * ```
 */
export declare function isVariable(node: unknown): node is types.VariableNode;
/**
 * 判断输入为 BackendVariable 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BackendVariable 节点没有继承类，此判断等价于`isStrictBackendVariable`
 * @example
 * ```ts
 * if (isBackendVariable(node)) {
 *   // 在这个花括号内，node 的类型是 BackendVariable 或者 BackendVariable 继承类型
 * }
 * ```
 */
export declare function isBackendVariable(node: unknown): node is BackendVariable;
/**
 * 判断输入为 FrontendVariable 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，FrontendVariable 节点没有继承类，此判断等价于`isStrictFrontendVariable`
 * @example
 * ```ts
 * if (isFrontendVariable(node)) {
 *   // 在这个花括号内，node 的类型是 FrontendVariable 或者 FrontendVariable 继承类型
 * }
 * ```
 */
export declare function isFrontendVariable(node: unknown): node is FrontendVariable;
/**
 * 判断输入为 Constant 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Constant 节点没有继承类，此判断等价于`isStrictConstant`
 * @example
 * ```ts
 * if (isConstant(node)) {
 *   // 在这个花括号内，node 的类型是 Constant 或者 Constant 继承类型
 * }
 * ```
 */
export declare function isConstant(node: unknown): node is Constant;
/**
 * 判断输入为 LogicItem 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isLogicItem(node)) {
 *   // 在这个花括号内，node 的类型是 LogicItem 或者 LogicItem 继承类型
 * }
 * ```
 */
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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Function 节点没有继承类，此判断等价于`isStrictFunction`
 * @example
 * ```ts
 * if (isFunction(node)) {
 *   // 在这个花括号内，node 的类型是 Function 或者 Function 继承类型
 * }
 * ```
 */
export declare function isFunction(node: unknown): node is Function;
/**
 * 判断输入为 AnonymousFunction 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AnonymousFunction 节点没有继承类，此判断等价于`isStrictAnonymousFunction`
 * @example
 * ```ts
 * if (isAnonymousFunction(node)) {
 *   // 在这个花括号内，node 的类型是 AnonymousFunction 或者 AnonymousFunction 继承类型
 * }
 * ```
 */
export declare function isAnonymousFunction(node: unknown): node is AnonymousFunction;
/**
 * 判断输入为 ImportedInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isImportedInterface(node)) {
 *   // 在这个花括号内，node 的类型是 ImportedInterface 或者 ImportedInterface 继承类型
 * }
 * ```
 */
export declare function isImportedInterface(node: unknown): node is types.ImportedInterfaceNode;
/**
 * 判断输入为 RetryConfig 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，RetryConfig 节点没有继承类，此判断等价于`isStrictRetryConfig`
 * @example
 * ```ts
 * if (isRetryConfig(node)) {
 *   // 在这个花括号内，node 的类型是 RetryConfig 或者 RetryConfig 继承类型
 * }
 * ```
 */
export declare function isRetryConfig(node: unknown): node is RetryConfig;
/**
 * 判断输入为 Interface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isInterface(node)) {
 *   // 在这个花括号内，node 的类型是 Interface 或者 Interface 继承类型
 * }
 * ```
 */
export declare function isInterface(node: unknown): node is types.InterfaceNode;
/**
 * 判断输入为 McpInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，McpInterface 节点没有继承类，此判断等价于`isStrictMcpInterface`
 * @example
 * ```ts
 * if (isMcpInterface(node)) {
 *   // 在这个花括号内，node 的类型是 McpInterface 或者 McpInterface 继承类型
 * }
 * ```
 */
export declare function isMcpInterface(node: unknown): node is McpInterface;
/**
 * 判断输入为 ConnectionInfo 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConnectionInfo 节点没有继承类，此判断等价于`isStrictConnectionInfo`
 * @example
 * ```ts
 * if (isConnectionInfo(node)) {
 *   // 在这个花括号内，node 的类型是 ConnectionInfo 或者 ConnectionInfo 继承类型
 * }
 * ```
 */
export declare function isConnectionInfo(node: unknown): node is ConnectionInfo;
/**
 * 判断输入为 MicroserviceInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MicroserviceInterface 节点没有继承类，此判断等价于`isStrictMicroserviceInterface`
 * @example
 * ```ts
 * if (isMicroserviceInterface(node)) {
 *   // 在这个花括号内，node 的类型是 MicroserviceInterface 或者 MicroserviceInterface 继承类型
 * }
 * ```
 */
export declare function isMicroserviceInterface(node: unknown): node is MicroserviceInterface;
/**
 * 判断输入为 GatewayInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，GatewayInterface 节点没有继承类，此判断等价于`isStrictGatewayInterface`
 * @example
 * ```ts
 * if (isGatewayInterface(node)) {
 *   // 在这个花括号内，node 的类型是 GatewayInterface 或者 GatewayInterface 继承类型
 * }
 * ```
 */
export declare function isGatewayInterface(node: unknown): node is GatewayInterface;
/**
 * 判断输入为 InterfaceParam 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，InterfaceParam 节点没有继承类，此判断等价于`isStrictInterfaceParam`
 * @example
 * ```ts
 * if (isInterfaceParam(node)) {
 *   // 在这个花括号内，node 的类型是 InterfaceParam 或者 InterfaceParam 继承类型
 * }
 * ```
 */
export declare function isInterfaceParam(node: unknown): node is InterfaceParam;
/**
 * 判断输入为 Transactional 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Transactional 节点没有继承类，此判断等价于`isStrictTransactional`
 * @example
 * ```ts
 * if (isTransactional(node)) {
 *   // 在这个花括号内，node 的类型是 Transactional 或者 Transactional 继承类型
 * }
 * ```
 */
export declare function isTransactional(node: unknown): node is Transactional;
/**
 * 判断输入为 DefaultValue 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，DefaultValue 节点没有继承类，此判断等价于`isStrictDefaultValue`
 * @example
 * ```ts
 * if (isDefaultValue(node)) {
 *   // 在这个花括号内，node 的类型是 DefaultValue 或者 DefaultValue 继承类型
 * }
 * ```
 */
export declare function isDefaultValue(node: unknown): node is DefaultValue;
/**
 * 判断输入为 Abort 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Abort 节点没有继承类，此判断等价于`isStrictAbort`
 * @example
 * ```ts
 * if (isAbort(node)) {
 *   // 在这个花括号内，node 的类型是 Abort 或者 Abort 继承类型
 * }
 * ```
 */
export declare function isAbort(node: unknown): node is Abort;
/**
 * 判断输入为 Start 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Start 节点没有继承类，此判断等价于`isStrictStart`
 * @example
 * ```ts
 * if (isStart(node)) {
 *   // 在这个花括号内，node 的类型是 Start 或者 Start 继承类型
 * }
 * ```
 */
export declare function isStart(node: unknown): node is Start;
/**
 * 判断输入为 End 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，End 节点没有继承类，此判断等价于`isStrictEnd`
 * @example
 * ```ts
 * if (isEnd(node)) {
 *   // 在这个花括号内，node 的类型是 End 或者 End 继承类型
 * }
 * ```
 */
export declare function isEnd(node: unknown): node is End;
/**
 * 判断输入为 IfStatement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，IfStatement 节点没有继承类，此判断等价于`isStrictIfStatement`
 * @example
 * ```ts
 * if (isIfStatement(node)) {
 *   // 在这个花括号内，node 的类型是 IfStatement 或者 IfStatement 继承类型
 * }
 * ```
 */
export declare function isIfStatement(node: unknown): node is IfStatement;
/**
 * 严格判断输入为 IfExpression 节点
 *
 * @description 仅判断节点本身，不包含继承类
 * @example
 * ```ts
 * if (isStrictIfExpression(node)) {
 *   // 在这个花括号内，node 的类型为 IfExpression
 * }
 * ```
 */
export declare function isStrictIfExpression(node: unknown): node is IfExpression;
/**
 * 判断输入为 SwitchStatement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SwitchStatement 节点没有继承类，此判断等价于`isStrictSwitchStatement`
 * @example
 * ```ts
 * if (isSwitchStatement(node)) {
 *   // 在这个花括号内，node 的类型是 SwitchStatement 或者 SwitchStatement 继承类型
 * }
 * ```
 */
export declare function isSwitchStatement(node: unknown): node is SwitchStatement;
/**
 * 判断输入为 SwitchCase 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SwitchCase 节点没有继承类，此判断等价于`isStrictSwitchCase`
 * @example
 * ```ts
 * if (isSwitchCase(node)) {
 *   // 在这个花括号内，node 的类型是 SwitchCase 或者 SwitchCase 继承类型
 * }
 * ```
 */
export declare function isSwitchCase(node: unknown): node is SwitchCase;
/**
 * 判断输入为 ForEachStatement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ForEachStatement 节点没有继承类，此判断等价于`isStrictForEachStatement`
 * @example
 * ```ts
 * if (isForEachStatement(node)) {
 *   // 在这个花括号内，node 的类型是 ForEachStatement 或者 ForEachStatement 继承类型
 * }
 * ```
 */
export declare function isForEachStatement(node: unknown): node is ForEachStatement;
/**
 * 判断输入为 WhileStatement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，WhileStatement 节点没有继承类，此判断等价于`isStrictWhileStatement`
 * @example
 * ```ts
 * if (isWhileStatement(node)) {
 *   // 在这个花括号内，node 的类型是 WhileStatement 或者 WhileStatement 继承类型
 * }
 * ```
 */
export declare function isWhileStatement(node: unknown): node is WhileStatement;
/**
 * 判断输入为 Break 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Break 节点没有继承类，此判断等价于`isStrictBreak`
 * @example
 * ```ts
 * if (isBreak(node)) {
 *   // 在这个花括号内，node 的类型是 Break 或者 Break 继承类型
 * }
 * ```
 */
export declare function isBreak(node: unknown): node is Break;
/**
 * 判断输入为 Continue 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Continue 节点没有继承类，此判断等价于`isStrictContinue`
 * @example
 * ```ts
 * if (isContinue(node)) {
 *   // 在这个花括号内，node 的类型是 Continue 或者 Continue 继承类型
 * }
 * ```
 */
export declare function isContinue(node: unknown): node is Continue;
/**
 * 判断输入为 Assignment 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Assignment 节点没有继承类，此判断等价于`isStrictAssignment`
 * @example
 * ```ts
 * if (isAssignment(node)) {
 *   // 在这个花括号内，node 的类型是 Assignment 或者 Assignment 继承类型
 * }
 * ```
 */
export declare function isAssignment(node: unknown): node is Assignment;
/**
 * 判断输入为 BatchAssignment 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BatchAssignment 节点没有继承类，此判断等价于`isStrictBatchAssignment`
 * @example
 * ```ts
 * if (isBatchAssignment(node)) {
 *   // 在这个花括号内，node 的类型是 BatchAssignment 或者 BatchAssignment 继承类型
 * }
 * ```
 */
export declare function isBatchAssignment(node: unknown): node is BatchAssignment;
/**
 * 判断输入为 Comment 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Comment 节点没有继承类，此判断等价于`isStrictComment`
 * @example
 * ```ts
 * if (isComment(node)) {
 *   // 在这个花括号内，node 的类型是 Comment 或者 Comment 继承类型
 * }
 * ```
 */
export declare function isComment(node: unknown): node is Comment;
/**
 * 判断输入为 CallLogic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isCallLogic(node)) {
 *   // 在这个花括号内，node 的类型是 CallLogic 或者 CallLogic 继承类型
 * }
 * ```
 */
export declare function isCallLogic(node: unknown): node is types.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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallFunction 节点没有继承类，此判断等价于`isStrictCallFunction`
 * @example
 * ```ts
 * if (isCallFunction(node)) {
 *   // 在这个花括号内，node 的类型是 CallFunction 或者 CallFunction 继承类型
 * }
 * ```
 */
export declare function isCallFunction(node: unknown): node is CallFunction;
/**
 * 判断输入为 CallInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isCallInterface(node)) {
 *   // 在这个花括号内，node 的类型是 CallInterface 或者 CallInterface 继承类型
 * }
 * ```
 */
export declare function isCallInterface(node: unknown): node is types.CallInterfaceNode;
/**
 * 判断输入为 CallMicroserviceInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallMicroserviceInterface 节点没有继承类，此判断等价于`isStrictCallMicroserviceInterface`
 * @example
 * ```ts
 * if (isCallMicroserviceInterface(node)) {
 *   // 在这个花括号内，node 的类型是 CallMicroserviceInterface 或者 CallMicroserviceInterface 继承类型
 * }
 * ```
 */
export declare function isCallMicroserviceInterface(node: unknown): node is CallMicroserviceInterface;
/**
 * 判断输入为 CallGatewayInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallGatewayInterface 节点没有继承类，此判断等价于`isStrictCallGatewayInterface`
 * @example
 * ```ts
 * if (isCallGatewayInterface(node)) {
 *   // 在这个花括号内，node 的类型是 CallGatewayInterface 或者 CallGatewayInterface 继承类型
 * }
 * ```
 */
export declare function isCallGatewayInterface(node: unknown): node is CallGatewayInterface;
/**
 * 判断输入为 Destination 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Destination 节点没有继承类，此判断等价于`isStrictDestination`
 * @example
 * ```ts
 * if (isDestination(node)) {
 *   // 在这个花括号内，node 的类型是 Destination 或者 Destination 继承类型
 * }
 * ```
 */
export declare function isDestination(node: unknown): node is Destination;
/**
 * 判断输入为 ExternalDestination 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ExternalDestination 节点没有继承类，此判断等价于`isStrictExternalDestination`
 * @example
 * ```ts
 * if (isExternalDestination(node)) {
 *   // 在这个花括号内，node 的类型是 ExternalDestination 或者 ExternalDestination 继承类型
 * }
 * ```
 */
export declare function isExternalDestination(node: unknown): node is ExternalDestination;
/**
 * 判断输入为 AbstractValidation 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isAbstractValidation(node)) {
 *   // 在这个花括号内，node 的类型是 AbstractValidation 或者 AbstractValidation 继承类型
 * }
 * ```
 */
export declare function isAbstractValidation(node: unknown): node is types.AbstractValidationNode;
/**
 * 判断输入为 ValidationRule 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ValidationRule 节点没有继承类，此判断等价于`isStrictValidationRule`
 * @example
 * ```ts
 * if (isValidationRule(node)) {
 *   // 在这个花括号内，node 的类型是 ValidationRule 或者 ValidationRule 继承类型
 * }
 * ```
 */
export declare function isValidationRule(node: unknown): node is ValidationRule;
/**
 * 判断输入为 ValidationLogic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ValidationLogic 节点没有继承类，此判断等价于`isStrictValidationLogic`
 * @example
 * ```ts
 * if (isValidationLogic(node)) {
 *   // 在这个花括号内，node 的类型是 ValidationLogic 或者 ValidationLogic 继承类型
 * }
 * ```
 */
export declare function isValidationLogic(node: unknown): node is ValidationLogic;
/**
 * 判断输入为 Argument 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Argument 节点没有继承类，此判断等价于`isStrictArgument`
 * @example
 * ```ts
 * if (isArgument(node)) {
 *   // 在这个花括号内，node 的类型是 Argument 或者 Argument 继承类型
 * }
 * ```
 */
export declare function isArgument(node: unknown): node is Argument;
/**
 * 判断输入为 Anchor 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Anchor 节点没有继承类，此判断等价于`isStrictAnchor`
 * @example
 * ```ts
 * if (isAnchor(node)) {
 *   // 在这个花括号内，node 的类型是 Anchor 或者 Anchor 继承类型
 * }
 * ```
 */
export declare function isAnchor(node: unknown): node is Anchor;
/**
 * 判断输入为 JSBlock 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，JSBlock 节点没有继承类，此判断等价于`isStrictJSBlock`
 * @example
 * ```ts
 * if (isJSBlock(node)) {
 *   // 在这个花括号内，node 的类型是 JSBlock 或者 JSBlock 继承类型
 * }
 * ```
 */
export declare function isJSBlock(node: unknown): node is JSBlock;
/**
 * 判断输入为 JavaLogic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，JavaLogic 节点没有继承类，此判断等价于`isStrictJavaLogic`
 * @example
 * ```ts
 * if (isJavaLogic(node)) {
 *   // 在这个花括号内，node 的类型是 JavaLogic 或者 JavaLogic 继承类型
 * }
 * ```
 */
export declare function isJavaLogic(node: unknown): node is JavaLogic;
/**
 * 判断输入为 Block 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Block 节点没有继承类，此判断等价于`isStrictBlock`
 * @example
 * ```ts
 * if (isBlock(node)) {
 *   // 在这个花括号内，node 的类型是 Block 或者 Block 继承类型
 * }
 * ```
 */
export declare function isBlock(node: unknown): node is Block;
/**
 * 判断输入为 Identifier 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Identifier 节点没有继承类，此判断等价于`isStrictIdentifier`
 * @example
 * ```ts
 * if (isIdentifier(node)) {
 *   // 在这个花括号内，node 的类型是 Identifier 或者 Identifier 继承类型
 * }
 * ```
 */
export declare function isIdentifier(node: unknown): node is Identifier;
/**
 * 判断输入为 NullLiteral 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NullLiteral 节点没有继承类，此判断等价于`isStrictNullLiteral`
 * @example
 * ```ts
 * if (isNullLiteral(node)) {
 *   // 在这个花括号内，node 的类型是 NullLiteral 或者 NullLiteral 继承类型
 * }
 * ```
 */
export declare function isNullLiteral(node: unknown): node is NullLiteral;
/**
 * 判断输入为 BooleanLiteral 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BooleanLiteral 节点没有继承类，此判断等价于`isStrictBooleanLiteral`
 * @example
 * ```ts
 * if (isBooleanLiteral(node)) {
 *   // 在这个花括号内，node 的类型是 BooleanLiteral 或者 BooleanLiteral 继承类型
 * }
 * ```
 */
export declare function isBooleanLiteral(node: unknown): node is BooleanLiteral;
/**
 * 判断输入为 StringLiteral 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，StringLiteral 节点没有继承类，此判断等价于`isStrictStringLiteral`
 * @example
 * ```ts
 * if (isStringLiteral(node)) {
 *   // 在这个花括号内，node 的类型是 StringLiteral 或者 StringLiteral 继承类型
 * }
 * ```
 */
export declare function isStringLiteral(node: unknown): node is StringLiteral;
/**
 * 判断输入为 StringInterpolation 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，StringInterpolation 节点没有继承类，此判断等价于`isStrictStringInterpolation`
 * @example
 * ```ts
 * if (isStringInterpolation(node)) {
 *   // 在这个花括号内，node 的类型是 StringInterpolation 或者 StringInterpolation 继承类型
 * }
 * ```
 */
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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NumericLiteral 节点没有继承类，此判断等价于`isStrictNumericLiteral`
 * @example
 * ```ts
 * if (isNumericLiteral(node)) {
 *   // 在这个花括号内，node 的类型是 NumericLiteral 或者 NumericLiteral 继承类型
 * }
 * ```
 */
export declare function isNumericLiteral(node: unknown): node is NumericLiteral;
/**
 * 判断输入为 BinaryExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，BinaryExpression 节点没有继承类，此判断等价于`isStrictBinaryExpression`
 * @example
 * ```ts
 * if (isBinaryExpression(node)) {
 *   // 在这个花括号内，node 的类型是 BinaryExpression 或者 BinaryExpression 继承类型
 * }
 * ```
 */
export declare function isBinaryExpression(node: unknown): node is BinaryExpression;
/**
 * 判断输入为 VariadicExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，VariadicExpression 节点没有继承类，此判断等价于`isStrictVariadicExpression`
 * @example
 * ```ts
 * if (isVariadicExpression(node)) {
 *   // 在这个花括号内，node 的类型是 VariadicExpression 或者 VariadicExpression 继承类型
 * }
 * ```
 */
export declare function isVariadicExpression(node: unknown): node is VariadicExpression;
/**
 * 判断输入为 MatchCase 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MatchCase 节点没有继承类，此判断等价于`isStrictMatchCase`
 * @example
 * ```ts
 * if (isMatchCase(node)) {
 *   // 在这个花括号内，node 的类型是 MatchCase 或者 MatchCase 继承类型
 * }
 * ```
 */
export declare function isMatchCase(node: unknown): node is MatchCase;
/**
 * 判断输入为 Match 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Match 节点没有继承类，此判断等价于`isStrictMatch`
 * @example
 * ```ts
 * if (isMatch(node)) {
 *   // 在这个花括号内，node 的类型是 Match 或者 Match 继承类型
 * }
 * ```
 */
export declare function isMatch(node: unknown): node is Match;
/**
 * 判断输入为 UnaryExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，UnaryExpression 节点没有继承类，此判断等价于`isStrictUnaryExpression`
 * @example
 * ```ts
 * if (isUnaryExpression(node)) {
 *   // 在这个花括号内，node 的类型是 UnaryExpression 或者 UnaryExpression 继承类型
 * }
 * ```
 */
export declare function isUnaryExpression(node: unknown): node is UnaryExpression;
/**
 * 判断输入为 MemberExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MemberExpression 节点没有继承类，此判断等价于`isStrictMemberExpression`
 * @example
 * ```ts
 * if (isMemberExpression(node)) {
 *   // 在这个花括号内，node 的类型是 MemberExpression 或者 MemberExpression 继承类型
 * }
 * ```
 */
export declare function isMemberExpression(node: unknown): node is MemberExpression;
/**
 * 判断输入为 Unparsed 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Unparsed 节点没有继承类，此判断等价于`isStrictUnparsed`
 * @example
 * ```ts
 * if (isUnparsed(node)) {
 *   // 在这个花括号内，node 的类型是 Unparsed 或者 Unparsed 继承类型
 * }
 * ```
 */
export declare function isUnparsed(node: unknown): node is Unparsed;
/**
 * 判断输入为 New 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，New 节点没有继承类，此判断等价于`isStrictNew`
 * @example
 * ```ts
 * if (isNew(node)) {
 *   // 在这个花括号内，node 的类型是 New 或者 New 继承类型
 * }
 * ```
 */
export declare function isNew(node: unknown): node is New;
/**
 * 判断输入为 NewComposite 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NewComposite 节点没有继承类，此判断等价于`isStrictNewComposite`
 * @example
 * ```ts
 * if (isNewComposite(node)) {
 *   // 在这个花括号内，node 的类型是 NewComposite 或者 NewComposite 继承类型
 * }
 * ```
 */
export declare function isNewComposite(node: unknown): node is NewComposite;
/**
 * 判断输入为 NewStructure 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NewStructure 节点没有继承类，此判断等价于`isStrictNewStructure`
 * @example
 * ```ts
 * if (isNewStructure(node)) {
 *   // 在这个花括号内，node 的类型是 NewStructure 或者 NewStructure 继承类型
 * }
 * ```
 */
export declare function isNewStructure(node: unknown): node is NewStructure;
/**
 * 判断输入为 NewList 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NewList 节点没有继承类，此判断等价于`isStrictNewList`
 * @example
 * ```ts
 * if (isNewList(node)) {
 *   // 在这个花括号内，node 的类型是 NewList 或者 NewList 继承类型
 * }
 * ```
 */
export declare function isNewList(node: unknown): node is NewList;
/**
 * 判断输入为 NewMap 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NewMap 节点没有继承类，此判断等价于`isStrictNewMap`
 * @example
 * ```ts
 * if (isNewMap(node)) {
 *   // 在这个花括号内，node 的类型是 NewMap 或者 NewMap 继承类型
 * }
 * ```
 */
export declare function isNewMap(node: unknown): node is NewMap;
/**
 * 判断输入为 NewRegex 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，NewRegex 节点没有继承类，此判断等价于`isStrictNewRegex`
 * @example
 * ```ts
 * if (isNewRegex(node)) {
 *   // 在这个花括号内，node 的类型是 NewRegex 或者 NewRegex 继承类型
 * }
 * ```
 */
export declare function isNewRegex(node: unknown): node is NewRegex;
/**
 * 判断输入为 Paginate 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Paginate 节点没有继承类，此判断等价于`isStrictPaginate`
 * @example
 * ```ts
 * if (isPaginate(node)) {
 *   // 在这个花括号内，node 的类型是 Paginate 或者 Paginate 继承类型
 * }
 * ```
 */
export declare function isPaginate(node: unknown): node is Paginate;
/**
 * 判断输入为 CallQueryComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallQueryComponent 节点没有继承类，此判断等价于`isStrictCallQueryComponent`
 * @example
 * ```ts
 * if (isCallQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型是 CallQueryComponent 或者 CallQueryComponent 继承类型
 * }
 * ```
 */
export declare function isCallQueryComponent(node: unknown): node is CallQueryComponent;
/**
 * 判断输入为 QuerySelectExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QuerySelectExpression 节点没有继承类，此判断等价于`isStrictQuerySelectExpression`
 * @example
 * ```ts
 * if (isQuerySelectExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QuerySelectExpression 或者 QuerySelectExpression 继承类型
 * }
 * ```
 */
export declare function isQuerySelectExpression(node: unknown): node is QuerySelectExpression;
/**
 * 判断输入为 QueryFromExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryFromExpression 节点没有继承类，此判断等价于`isStrictQueryFromExpression`
 * @example
 * ```ts
 * if (isQueryFromExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryFromExpression 或者 QueryFromExpression 继承类型
 * }
 * ```
 */
export declare function isQueryFromExpression(node: unknown): node is QueryFromExpression;
/**
 * 判断输入为 QueryJoinExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryJoinExpression 节点没有继承类，此判断等价于`isStrictQueryJoinExpression`
 * @example
 * ```ts
 * if (isQueryJoinExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryJoinExpression 或者 QueryJoinExpression 继承类型
 * }
 * ```
 */
export declare function isQueryJoinExpression(node: unknown): node is QueryJoinExpression;
/**
 * 判断输入为 QueryFieldExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryFieldExpression 节点没有继承类，此判断等价于`isStrictQueryFieldExpression`
 * @example
 * ```ts
 * if (isQueryFieldExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryFieldExpression 或者 QueryFieldExpression 继承类型
 * }
 * ```
 */
export declare function isQueryFieldExpression(node: unknown): node is QueryFieldExpression;
/**
 * 判断输入为 QueryAggregateExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryAggregateExpression 节点没有继承类，此判断等价于`isStrictQueryAggregateExpression`
 * @example
 * ```ts
 * if (isQueryAggregateExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryAggregateExpression 或者 QueryAggregateExpression 继承类型
 * }
 * ```
 */
export declare function isQueryAggregateExpression(node: unknown): node is QueryAggregateExpression;
/**
 * 判断输入为 QueryOrderByExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryOrderByExpression 节点没有继承类，此判断等价于`isStrictQueryOrderByExpression`
 * @example
 * ```ts
 * if (isQueryOrderByExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryOrderByExpression 或者 QueryOrderByExpression 继承类型
 * }
 * ```
 */
export declare function isQueryOrderByExpression(node: unknown): node is QueryOrderByExpression;
/**
 * 判断输入为 QueryGroupByExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryGroupByExpression 节点没有继承类，此判断等价于`isStrictQueryGroupByExpression`
 * @example
 * ```ts
 * if (isQueryGroupByExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryGroupByExpression 或者 QueryGroupByExpression 继承类型
 * }
 * ```
 */
export declare function isQueryGroupByExpression(node: unknown): node is QueryGroupByExpression;
/**
 * 判断输入为 QueryLimitExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，QueryLimitExpression 节点没有继承类，此判断等价于`isStrictQueryLimitExpression`
 * @example
 * ```ts
 * if (isQueryLimitExpression(node)) {
 *   // 在这个花括号内，node 的类型是 QueryLimitExpression 或者 QueryLimitExpression 继承类型
 * }
 * ```
 */
export declare function isQueryLimitExpression(node: unknown): node is QueryLimitExpression;
/**
 * 判断输入为 SqlQueryComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SqlQueryComponent 节点没有继承类，此判断等价于`isStrictSqlQueryComponent`
 * @example
 * ```ts
 * if (isSqlQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型是 SqlQueryComponent 或者 SqlQueryComponent 继承类型
 * }
 * ```
 */
export declare function isSqlQueryComponent(node: unknown): node is SqlQueryComponent;
/**
 * 判断输入为 OqlQueryComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，OqlQueryComponent 节点没有继承类，此判断等价于`isStrictOqlQueryComponent`
 * @example
 * ```ts
 * if (isOqlQueryComponent(node)) {
 *   // 在这个花括号内，node 的类型是 OqlQueryComponent 或者 OqlQueryComponent 继承类型
 * }
 * ```
 */
export declare function isOqlQueryComponent(node: unknown): node is OqlQueryComponent;
/**
 * 判断输入为 Process 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Process 节点没有继承类，此判断等价于`isStrictProcess`
 * @example
 * ```ts
 * if (isProcess(node)) {
 *   // 在这个花括号内，node 的类型是 Process 或者 Process 继承类型
 * }
 * ```
 */
export declare function isProcess(node: unknown): node is Process;
/**
 * 判断输入为 ProcessElement 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessElement 节点没有继承类，此判断等价于`isStrictProcessElement`
 * @example
 * ```ts
 * if (isProcessElement(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessElement 或者 ProcessElement 继承类型
 * }
 * ```
 */
export declare function isProcessElement(node: unknown): node is ProcessElement;
/**
 * 判断输入为 ProcessComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessComponent 节点没有继承类，此判断等价于`isStrictProcessComponent`
 * @example
 * ```ts
 * if (isProcessComponent(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessComponent 或者 ProcessComponent 继承类型
 * }
 * ```
 */
export declare function isProcessComponent(node: unknown): node is ProcessComponent;
/**
 * 判断输入为 MultiApprovalPolicy 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isMultiApprovalPolicy(node)) {
 *   // 在这个花括号内，node 的类型是 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
 * }
 * ```
 */
export declare function isMultiApprovalPolicy(node: unknown): node is types.MultiApprovalPolicyNode;
/**
 * 判断输入为 SequentialPolicy 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SequentialPolicy 节点没有继承类，此判断等价于`isStrictSequentialPolicy`
 * @example
 * ```ts
 * if (isSequentialPolicy(node)) {
 *   // 在这个花括号内，node 的类型是 SequentialPolicy 或者 SequentialPolicy 继承类型
 * }
 * ```
 */
export declare function isSequentialPolicy(node: unknown): node is SequentialPolicy;
/**
 * 判断输入为 CountersignPolicy 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CountersignPolicy 节点没有继承类，此判断等价于`isStrictCountersignPolicy`
 * @example
 * ```ts
 * if (isCountersignPolicy(node)) {
 *   // 在这个花括号内，node 的类型是 CountersignPolicy 或者 CountersignPolicy 继承类型
 * }
 * ```
 */
export declare function isCountersignPolicy(node: unknown): node is CountersignPolicy;
/**
 * 判断输入为 ProcessOutcome 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessOutcome 节点没有继承类，此判断等价于`isStrictProcessOutcome`
 * @example
 * ```ts
 * if (isProcessOutcome(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessOutcome 或者 ProcessOutcome 继承类型
 * }
 * ```
 */
export declare function isProcessOutcome(node: unknown): node is ProcessOutcome;
/**
 * 判断输入为 Assignee 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Assignee 节点没有继承类，此判断等价于`isStrictAssignee`
 * @example
 * ```ts
 * if (isAssignee(node)) {
 *   // 在这个花括号内，node 的类型是 Assignee 或者 Assignee 继承类型
 * }
 * ```
 */
export declare function isAssignee(node: unknown): node is Assignee;
/**
 * 判断输入为 ProcessOutcomes 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessOutcomes 节点没有继承类，此判断等价于`isStrictProcessOutcomes`
 * @example
 * ```ts
 * if (isProcessOutcomes(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessOutcomes 或者 ProcessOutcomes 继承类型
 * }
 * ```
 */
export declare function isProcessOutcomes(node: unknown): node is ProcessOutcomes;
/**
 * 判断输入为 Role 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Role 节点没有继承类，此判断等价于`isStrictRole`
 * @example
 * ```ts
 * if (isRole(node)) {
 *   // 在这个花括号内，node 的类型是 Role 或者 Role 继承类型
 * }
 * ```
 */
export declare function isRole(node: unknown): node is Role;
/**
 * 判断输入为 Configuration 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Configuration 节点没有继承类，此判断等价于`isStrictConfiguration`
 * @example
 * ```ts
 * if (isConfiguration(node)) {
 *   // 在这个花括号内，node 的类型是 Configuration 或者 Configuration 继承类型
 * }
 * ```
 */
export declare function isConfiguration(node: unknown): node is Configuration;
/**
 * 判断输入为 ConfigGroup 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConfigGroup 节点没有继承类，此判断等价于`isStrictConfigGroup`
 * @example
 * ```ts
 * if (isConfigGroup(node)) {
 *   // 在这个花括号内，node 的类型是 ConfigGroup 或者 ConfigGroup 继承类型
 * }
 * ```
 */
export declare function isConfigGroup(node: unknown): node is ConfigGroup;
/**
 * 判断输入为 ConfigProperty 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConfigProperty 节点没有继承类，此判断等价于`isStrictConfigProperty`
 * @example
 * ```ts
 * if (isConfigProperty(node)) {
 *   // 在这个花括号内，node 的类型是 ConfigProperty 或者 ConfigProperty 继承类型
 * }
 * ```
 */
export declare function isConfigProperty(node: unknown): node is ConfigProperty;
/**
 * 判断输入为 ConfigPropertyValue 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConfigPropertyValue 节点没有继承类，此判断等价于`isStrictConfigPropertyValue`
 * @example
 * ```ts
 * if (isConfigPropertyValue(node)) {
 *   // 在这个花括号内，node 的类型是 ConfigPropertyValue 或者 ConfigPropertyValue 继承类型
 * }
 * ```
 */
export declare function isConfigPropertyValue(node: unknown): node is ConfigPropertyValue;
/**
 * 判断输入为 I18nInfo 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，I18nInfo 节点没有继承类，此判断等价于`isStrictI18nInfo`
 * @example
 * ```ts
 * if (isI18nInfo(node)) {
 *   // 在这个花括号内，node 的类型是 I18nInfo 或者 I18nInfo 继承类型
 * }
 * ```
 */
export declare function isI18nInfo(node: unknown): node is I18nInfo;
/**
 * 判断输入为 StyleInfo 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，StyleInfo 节点没有继承类，此判断等价于`isStrictStyleInfo`
 * @example
 * ```ts
 * if (isStyleInfo(node)) {
 *   // 在这个花括号内，node 的类型是 StyleInfo 或者 StyleInfo 继承类型
 * }
 * ```
 */
export declare function isStyleInfo(node: unknown): node is StyleInfo;
/**
 * 判断输入为 CompletionProperty 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CompletionProperty 节点没有继承类，此判断等价于`isStrictCompletionProperty`
 * @example
 * ```ts
 * if (isCompletionProperty(node)) {
 *   // 在这个花括号内，node 的类型是 CompletionProperty 或者 CompletionProperty 继承类型
 * }
 * ```
 */
export declare function isCompletionProperty(node: unknown): node is CompletionProperty;
/**
 * 判断输入为 UseComponent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，UseComponent 节点没有继承类，此判断等价于`isStrictUseComponent`
 * @example
 * ```ts
 * if (isUseComponent(node)) {
 *   // 在这个花括号内，node 的类型是 UseComponent 或者 UseComponent 继承类型
 * }
 * ```
 */
export declare function isUseComponent(node: unknown): node is UseComponent;
/**
 * 判断输入为 Point 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Point 节点没有继承类，此判断等价于`isStrictPoint`
 * @example
 * ```ts
 * if (isPoint(node)) {
 *   // 在这个花括号内，node 的类型是 Point 或者 Point 继承类型
 * }
 * ```
 */
export declare function isPoint(node: unknown): node is Point;
/**
 * 判断输入为 Rect 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Rect 节点没有继承类，此判断等价于`isStrictRect`
 * @example
 * ```ts
 * if (isRect(node)) {
 *   // 在这个花括号内，node 的类型是 Rect 或者 Rect 继承类型
 * }
 * ```
 */
export declare function isRect(node: unknown): node is Rect;
/**
 * 判断输入为 SelectMembers 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SelectMembers 节点没有继承类，此判断等价于`isStrictSelectMembers`
 * @example
 * ```ts
 * if (isSelectMembers(node)) {
 *   // 在这个花括号内，node 的类型是 SelectMembers 或者 SelectMembers 继承类型
 * }
 * ```
 */
export declare function isSelectMembers(node: unknown): node is SelectMembers;
/**
 * 判断输入为 AssignmentLine 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AssignmentLine 节点没有继承类，此判断等价于`isStrictAssignmentLine`
 * @example
 * ```ts
 * if (isAssignmentLine(node)) {
 *   // 在这个花括号内，node 的类型是 AssignmentLine 或者 AssignmentLine 继承类型
 * }
 * ```
 */
export declare function isAssignmentLine(node: unknown): node is AssignmentLine;
/**
 * 判断输入为 FrontendLibrary 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，FrontendLibrary 节点没有继承类，此判断等价于`isStrictFrontendLibrary`
 * @example
 * ```ts
 * if (isFrontendLibrary(node)) {
 *   // 在这个花括号内，node 的类型是 FrontendLibrary 或者 FrontendLibrary 继承类型
 * }
 * ```
 */
export declare function isFrontendLibrary(node: unknown): node is FrontendLibrary;
/**
 * 判断输入为 ViewBlock 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isViewBlock(node)) {
 *   // 在这个花括号内，node 的类型是 ViewBlock 或者 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 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AuthInterface 节点没有继承类，此判断等价于`isStrictAuthInterface`
 * @example
 * ```ts
 * if (isAuthInterface(node)) {
 *   // 在这个花括号内，node 的类型是 AuthInterface 或者 AuthInterface 继承类型
 * }
 * ```
 */
export declare function isAuthInterface(node: unknown): node is AuthInterface;
/**
 * 判断输入为 CallAuthInterface 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallAuthInterface 节点没有继承类，此判断等价于`isStrictCallAuthInterface`
 * @example
 * ```ts
 * if (isCallAuthInterface(node)) {
 *   // 在这个花括号内，node 的类型是 CallAuthInterface 或者 CallAuthInterface 继承类型
 * }
 * ```
 */
export declare function isCallAuthInterface(node: unknown): node is CallAuthInterface;
/**
 * 判断输入为 TriggerEvent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isTriggerEvent(node)) {
 *   // 在这个花括号内，node 的类型是 TriggerEvent 或者 TriggerEvent 继承类型
 * }
 * ```
 */
export declare function isTriggerEvent(node: unknown): node is types.TriggerEventNode;
/**
 * 判断输入为 MsgTriggerEvent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MsgTriggerEvent 节点没有继承类，此判断等价于`isStrictMsgTriggerEvent`
 * @example
 * ```ts
 * if (isMsgTriggerEvent(node)) {
 *   // 在这个花括号内，node 的类型是 MsgTriggerEvent 或者 MsgTriggerEvent 继承类型
 * }
 * ```
 */
export declare function isMsgTriggerEvent(node: unknown): node is MsgTriggerEvent;
/**
 * 判断输入为 InterfaceTriggerEvent 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，InterfaceTriggerEvent 节点没有继承类，此判断等价于`isStrictInterfaceTriggerEvent`
 * @example
 * ```ts
 * if (isInterfaceTriggerEvent(node)) {
 *   // 在这个花括号内，node 的类型是 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
 * }
 * ```
 */
export declare function isInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent;
/**
 * 判断输入为 ConnectorTrigger 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConnectorTrigger 节点没有继承类，此判断等价于`isStrictConnectorTrigger`
 * @example
 * ```ts
 * if (isConnectorTrigger(node)) {
 *   // 在这个花括号内，node 的类型是 ConnectorTrigger 或者 ConnectorTrigger 继承类型
 * }
 * ```
 */
export declare function isConnectorTrigger(node: unknown): node is ConnectorTrigger;
/**
 * 判断输入为 TriggerLauncher 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型是 TriggerLauncher 或者 TriggerLauncher 继承类型
 * }
 * ```
 */
export declare function isTriggerLauncher(node: unknown): node is types.TriggerLauncherNode;
/**
 * 判断输入为 ConnectorTriggerLauncher 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isConnectorTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型是 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
 * }
 * ```
 */
export declare function isConnectorTriggerLauncher(node: unknown): node is types.ConnectorTriggerLauncherNode;
/**
 * 判断输入为 MsgTriggerLauncher 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，MsgTriggerLauncher 节点没有继承类，此判断等价于`isStrictMsgTriggerLauncher`
 * @example
 * ```ts
 * if (isMsgTriggerLauncher(node)) {
 *   // 在这个花括号内，node 的类型是 MsgTriggerLauncher 或者 MsgTriggerLauncher 继承类型
 * }
 * ```
 */
export declare function isMsgTriggerLauncher(node: unknown): node is MsgTriggerLauncher;
/**
 * 判断输入为 Dependency 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Dependency 节点没有继承类，此判断等价于`isStrictDependency`
 * @example
 * ```ts
 * if (isDependency(node)) {
 *   // 在这个花括号内，node 的类型是 Dependency 或者 Dependency 继承类型
 * }
 * ```
 */
export declare function isDependency(node: unknown): node is Dependency;
/**
 * 判断输入为 Connector 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Connector 节点没有继承类，此判断等价于`isStrictConnector`
 * @example
 * ```ts
 * if (isConnector(node)) {
 *   // 在这个花括号内，node 的类型是 Connector 或者 Connector 继承类型
 * }
 * ```
 */
export declare function isConnector(node: unknown): node is Connector;
/**
 * 判断输入为 CallConnector 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CallConnector 节点没有继承类，此判断等价于`isStrictCallConnector`
 * @example
 * ```ts
 * if (isCallConnector(node)) {
 *   // 在这个花括号内，node 的类型是 CallConnector 或者 CallConnector 继承类型
 * }
 * ```
 */
export declare function isCallConnector(node: unknown): node is CallConnector;
/**
 * 判断输入为 Connection 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，Connection 节点没有继承类，此判断等价于`isStrictConnection`
 * @example
 * ```ts
 * if (isConnection(node)) {
 *   // 在这个花括号内，node 的类型是 Connection 或者 Connection 继承类型
 * }
 * ```
 */
export declare function isConnection(node: unknown): node is Connection;
/**
 * 判断输入为 ConnectorLogic 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ConnectorLogic 节点没有继承类，此判断等价于`isStrictConnectorLogic`
 * @example
 * ```ts
 * if (isConnectorLogic(node)) {
 *   // 在这个花括号内，node 的类型是 ConnectorLogic 或者 ConnectorLogic 继承类型
 * }
 * ```
 */
export declare function isConnectorLogic(node: unknown): node is ConnectorLogic;
/**
 * 判断输入为 ProcessV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessV2 节点没有继承类，此判断等价于`isStrictProcessV2`
 * @example
 * ```ts
 * if (isProcessV2(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessV2 或者 ProcessV2 继承类型
 * }
 * ```
 */
export declare function isProcessV2(node: unknown): node is ProcessV2;
/**
 * 判断输入为 ProcessDefinitionV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessDefinitionV2 节点没有继承类，此判断等价于`isStrictProcessDefinitionV2`
 * @example
 * ```ts
 * if (isProcessDefinitionV2(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessDefinitionV2 或者 ProcessDefinitionV2 继承类型
 * }
 * ```
 */
export declare function isProcessDefinitionV2(node: unknown): node is ProcessDefinitionV2;
/**
 * 判断输入为 HistoryProcessV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，HistoryProcessV2 节点没有继承类，此判断等价于`isStrictHistoryProcessV2`
 * @example
 * ```ts
 * if (isHistoryProcessV2(node)) {
 *   // 在这个花括号内，node 的类型是 HistoryProcessV2 或者 HistoryProcessV2 继承类型
 * }
 * ```
 */
export declare function isHistoryProcessV2(node: unknown): node is HistoryProcessV2;
/**
 * 判断输入为 ProcessBindV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessBindV2 节点没有继承类，此判断等价于`isStrictProcessBindV2`
 * @example
 * ```ts
 * if (isProcessBindV2(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessBindV2 或者 ProcessBindV2 继承类型
 * }
 * ```
 */
export declare function isProcessBindV2(node: unknown): node is ProcessBindV2;
/**
 * 判断输入为 FieldPermissionV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，FieldPermissionV2 节点没有继承类，此判断等价于`isStrictFieldPermissionV2`
 * @example
 * ```ts
 * if (isFieldPermissionV2(node)) {
 *   // 在这个花括号内，node 的类型是 FieldPermissionV2 或者 FieldPermissionV2 继承类型
 * }
 * ```
 */
export declare function isFieldPermissionV2(node: unknown): node is FieldPermissionV2;
/**
 * 判断输入为 ProcessElementV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ProcessElementV2 节点没有继承类，此判断等价于`isStrictProcessElementV2`
 * @example
 * ```ts
 * if (isProcessElementV2(node)) {
 *   // 在这个花括号内，node 的类型是 ProcessElementV2 或者 ProcessElementV2 继承类型
 * }
 * ```
 */
export declare function isProcessElementV2(node: unknown): node is ProcessElementV2;
/**
 * 判断输入为 SubProcessDataMappingRule 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SubProcessDataMappingRule 节点没有继承类，此判断等价于`isStrictSubProcessDataMappingRule`
 * @example
 * ```ts
 * if (isSubProcessDataMappingRule(node)) {
 *   // 在这个花括号内，node 的类型是 SubProcessDataMappingRule 或者 SubProcessDataMappingRule 继承类型
 * }
 * ```
 */
export declare function isSubProcessDataMappingRule(node: unknown): node is SubProcessDataMappingRule;
/**
 * 判断输入为 OperatePermissionV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，OperatePermissionV2 节点没有继承类，此判断等价于`isStrictOperatePermissionV2`
 * @example
 * ```ts
 * if (isOperatePermissionV2(node)) {
 *   // 在这个花括号内，node 的类型是 OperatePermissionV2 或者 OperatePermissionV2 继承类型
 * }
 * ```
 */
export declare function isOperatePermissionV2(node: unknown): node is OperatePermissionV2;
/**
 * 判断输入为 AssigneeV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AssigneeV2 节点没有继承类，此判断等价于`isStrictAssigneeV2`
 * @example
 * ```ts
 * if (isAssigneeV2(node)) {
 *   // 在这个花括号内，node 的类型是 AssigneeV2 或者 AssigneeV2 继承类型
 * }
 * ```
 */
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;
/**
 * 判断输入为 Assignees 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isAssignees(node)) {
 *   // 在这个花括号内，node 的类型是 Assignees 或者 Assignees 继承类型
 * }
 * ```
 */
export declare function isAssignees(node: unknown): node is types.AssigneesNode;
/**
 * 判断输入为 UserAssignees 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，UserAssignees 节点没有继承类，此判断等价于`isStrictUserAssignees`
 * @example
 * ```ts
 * if (isUserAssignees(node)) {
 *   // 在这个花括号内，node 的类型是 UserAssignees 或者 UserAssignees 继承类型
 * }
 * ```
 */
export declare function isUserAssignees(node: unknown): node is UserAssignees;
/**
 * 判断输入为 RoleAssignees 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，RoleAssignees 节点没有继承类，此判断等价于`isStrictRoleAssignees`
 * @example
 * ```ts
 * if (isRoleAssignees(node)) {
 *   // 在这个花括号内，node 的类型是 RoleAssignees 或者 RoleAssignees 继承类型
 * }
 * ```
 */
export declare function isRoleAssignees(node: unknown): node is RoleAssignees;
/**
 * 判断输入为 DepartmentAssignees 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，DepartmentAssignees 节点没有继承类，此判断等价于`isStrictDepartmentAssignees`
 * @example
 * ```ts
 * if (isDepartmentAssignees(node)) {
 *   // 在这个花括号内，node 的类型是 DepartmentAssignees 或者 DepartmentAssignees 继承类型
 * }
 * ```
 */
export declare function isDepartmentAssignees(node: unknown): node is DepartmentAssignees;
/**
 * 判断输入为 FlowConditionV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，FlowConditionV2 节点没有继承类，此判断等价于`isStrictFlowConditionV2`
 * @example
 * ```ts
 * if (isFlowConditionV2(node)) {
 *   // 在这个花括号内，node 的类型是 FlowConditionV2 或者 FlowConditionV2 继承类型
 * }
 * ```
 */
export declare function isFlowConditionV2(node: unknown): node is FlowConditionV2;
/**
 * 判断输入为 ApprovalPolicyV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isApprovalPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型是 ApprovalPolicyV2 或者 ApprovalPolicyV2 继承类型
 * }
 * ```
 */
export declare function isApprovalPolicyV2(node: unknown): node is types.ApprovalPolicyV2Node;
/**
 * 判断输入为 SequentialPolicyV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，SequentialPolicyV2 节点没有继承类，此判断等价于`isStrictSequentialPolicyV2`
 * @example
 * ```ts
 * if (isSequentialPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型是 SequentialPolicyV2 或者 SequentialPolicyV2 继承类型
 * }
 * ```
 */
export declare function isSequentialPolicyV2(node: unknown): node is SequentialPolicyV2;
/**
 * 判断输入为 CountersignPolicyV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，CountersignPolicyV2 节点没有继承类，此判断等价于`isStrictCountersignPolicyV2`
 * @example
 * ```ts
 * if (isCountersignPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型是 CountersignPolicyV2 或者 CountersignPolicyV2 继承类型
 * }
 * ```
 */
export declare function isCountersignPolicyV2(node: unknown): node is CountersignPolicyV2;
/**
 * 判断输入为 OrSignPolicyV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，OrSignPolicyV2 节点没有继承类，此判断等价于`isStrictOrSignPolicyV2`
 * @example
 * ```ts
 * if (isOrSignPolicyV2(node)) {
 *   // 在这个花括号内，node 的类型是 OrSignPolicyV2 或者 OrSignPolicyV2 继承类型
 * }
 * ```
 */
export declare function isOrSignPolicyV2(node: unknown): node is OrSignPolicyV2;
/**
 * 判断输入为 UnmannedApprovalStrategyV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算
 * @example
 * ```ts
 * if (isUnmannedApprovalStrategyV2(node)) {
 *   // 在这个花括号内，node 的类型是 UnmannedApprovalStrategyV2 或者 UnmannedApprovalStrategyV2 继承类型
 * }
 * ```
 */
export declare function isUnmannedApprovalStrategyV2(node: unknown): node is types.UnmannedApprovalStrategyV2Node;
/**
 * 判断输入为 AutoApproveUnmannedV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AutoApproveUnmannedV2 节点没有继承类，此判断等价于`isStrictAutoApproveUnmannedV2`
 * @example
 * ```ts
 * if (isAutoApproveUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型是 AutoApproveUnmannedV2 或者 AutoApproveUnmannedV2 继承类型
 * }
 * ```
 */
export declare function isAutoApproveUnmannedV2(node: unknown): node is AutoApproveUnmannedV2;
/**
 * 判断输入为 AutoRejectUnmannedV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，AutoRejectUnmannedV2 节点没有继承类，此判断等价于`isStrictAutoRejectUnmannedV2`
 * @example
 * ```ts
 * if (isAutoRejectUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型是 AutoRejectUnmannedV2 或者 AutoRejectUnmannedV2 继承类型
 * }
 * ```
 */
export declare function isAutoRejectUnmannedV2(node: unknown): node is AutoRejectUnmannedV2;
/**
 * 判断输入为 ReassignUnmannedV2 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，ReassignUnmannedV2 节点没有继承类，此判断等价于`isStrictReassignUnmannedV2`
 * @example
 * ```ts
 * if (isReassignUnmannedV2(node)) {
 *   // 在这个花括号内，node 的类型是 ReassignUnmannedV2 或者 ReassignUnmannedV2 继承类型
 * }
 * ```
 */
export declare function isReassignUnmannedV2(node: unknown): node is ReassignUnmannedV2;
/**
 * 严格断言为 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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictApp(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 App 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictApp(node: unknown): asserts node is App;
/**
 * 严格断言为 Module 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictModule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Module 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictModule(node: unknown): asserts node is Module;
/**
 * 严格断言为 Namespace 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNamespace(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Namespace 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNamespace(node: unknown): asserts node is Namespace;
/**
 * 严格断言为 Directory 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDirectory(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Directory 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDirectory(node: unknown): asserts node is Directory;
/**
 * 严格断言为 ReferredDefinition 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictReferredDefinition(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ReferredDefinition 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictReferredDefinition(node: unknown): asserts node is ReferredDefinition;
/**
 * 严格断言为 FrontendType 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFrontendType(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFrontendType(node: unknown): asserts node is FrontendType;
/**
 * 严格断言为 Frontend 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFrontend(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Frontend 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFrontend(node: unknown): asserts node is Frontend;
/**
 * 严格断言为 Backend 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBackend(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Backend 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBackend(node: unknown): asserts node is Backend;
/**
 * 严格断言为 Integration 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictIntegration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Integration 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictIntegration(node: unknown): asserts node is Integration;
/**
 * 严格断言为 MicroApp 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMicroApp(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MicroApp 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMicroApp(node: unknown): asserts node is MicroApp;
/**
 * 严格断言为 TypeAnnotation 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictTypeAnnotation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TypeAnnotation 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictTypeAnnotation(node: unknown): asserts node is TypeAnnotation;
/**
 * 严格断言为 DatabaseTypeAnnotation 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDatabaseTypeAnnotation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DatabaseTypeAnnotation 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDatabaseTypeAnnotation(node: unknown): asserts node is DatabaseTypeAnnotation;
/**
 * 严格断言为 TypeParam 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictTypeParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TypeParam 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictTypeParam(node: unknown): asserts node is TypeParam;
/**
 * 严格断言为 Structure 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStructure(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Structure 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictStructure(node: unknown): asserts node is Structure;
/**
 * 严格断言为 StructureProperty 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStructureProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StructureProperty 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictStructureProperty(node: unknown): asserts node is StructureProperty;
/**
 * 严格断言为 Enum 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEnum(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Enum 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEnum(node: unknown): asserts node is Enum;
/**
 * 严格断言为 EnumItem 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEnumItem(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumItem 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEnumItem(node: unknown): asserts node is EnumItem;
/**
 * 严格断言为 DataSource 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDataSource(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DataSource 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDataSource(node: unknown): asserts node is DataSource;
/**
 * 严格断言为 Entity 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEntity(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Entity 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEntity(node: unknown): asserts node is Entity;
/**
 * 严格断言为 EntityProperty 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEntityProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityProperty 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEntityProperty(node: unknown): asserts node is EntityProperty;
/**
 * 严格断言为 EntityIndex 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEntityIndex(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityIndex 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEntityIndex(node: unknown): asserts node is EntityIndex;
/**
 * 严格断言为 MetadataType 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMetadataType(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MetadataType 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMetadataType(node: unknown): asserts node is MetadataType;
/**
 * 严格断言为 View 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictView(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 View 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictView(node: unknown): asserts node is View;
/**
 * 严格断言为 ViewElement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictViewElement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewElement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictViewElement(node: unknown): asserts node is ViewElement;
/**
 * 严格断言为 BindAttribute 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBindAttribute(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBindAttribute(node: unknown): asserts node is BindAttribute;
/**
 * 严格断言为 BindDirective 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBindDirective(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBindDirective(node: unknown): asserts node is BindDirective;
/**
 * 严格断言为 BindEvent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBindEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBindEvent(node: unknown): asserts node is BindEvent;
/**
 * 严格断言为 BindStyle 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBindStyle(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBindStyle(node: unknown): asserts node is BindStyle;
/**
 * 严格断言为 ThemeVariable 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictThemeVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ThemeVariable 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictThemeVariable(node: unknown): asserts node is ThemeVariable;
/**
 * 严格断言为 CustomSetter 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCustomSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CustomSetter 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCustomSetter(node: unknown): asserts node is CustomSetter;
/**
 * 严格断言为 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
 * 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;
/**
 * 严格断言为 PropertyTransformSetter 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictPropertyTransformSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertyTransformSetter 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictPropertyTransformSetter(node: unknown): asserts node is PropertyTransformSetter;
/**
 * 严格断言为 AnonymousFunctionSetter 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAnonymousFunctionSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnonymousFunctionSetter 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAnonymousFunctionSetter(node: unknown): asserts node is AnonymousFunctionSetter;
/**
 * 严格断言为 DataSourceSetter 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDataSourceSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DataSourceSetter 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDataSourceSetter(node: unknown): asserts node is DataSourceSetter;
/**
 * 严格断言为 ViewComponentDeclaration 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictViewComponentDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration;
/**
 * 严格断言为 BusinessComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBusinessComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBusinessComponent(node: unknown): asserts node is BusinessComponent;
/**
 * 严格断言为 Attribute 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAttribute(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Attribute 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAttribute(node: unknown): asserts node is Attribute;
/**
 * 严格断言为 Event 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Event 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEvent(node: unknown): asserts node is Event;
/**
 * 严格断言为 PropDeclaration 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictPropDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictPropDeclaration(node: unknown): asserts node is PropDeclaration;
/**
 * 严格断言为 EventDeclaration 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEventDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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;
/**
 * 严格断言为 CSSRule 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCSSRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CSSRule 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCSSRule(node: unknown): asserts node is CSSRule;
/**
 * 严格断言为 Theme 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictTheme(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictTheme(node: unknown): asserts node is Theme;
/**
 * 严格断言为 Slot 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSlot(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSlot(node: unknown): asserts node is Slot;
/**
 * 严格断言为 ViewComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictViewComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictViewComponent(node: unknown): asserts node is ViewComponent;
/**
 * 严格断言为 Logic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictLogic(node: unknown): asserts node is Logic;
/**
 * 严格断言为 SharedScope 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSharedScope(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SharedScope 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSharedScope(node: unknown): asserts node is SharedScope;
/**
 * 严格断言为 PermissionForSharedScope 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictPermissionForSharedScope(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PermissionForSharedScope 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictPermissionForSharedScope(node: unknown): asserts node is PermissionForSharedScope;
/**
 * 严格断言为 AuthLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAuthLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic;
/**
 * 严格断言为 AuthLogicForCallInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAuthLogicForCallInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogicForCallInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAuthLogicForCallInterface(node: unknown): asserts node is AuthLogicForCallInterface;
/**
 * 严格断言为 OverriddenLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictOverriddenLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OverriddenLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Param 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictReturn(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Return 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictReturn(node: unknown): asserts node is Return;
/**
 * 严格断言为 Variable 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Variable 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictVariable(node: unknown): asserts node is Variable;
/**
 * 严格断言为 BackendVariable 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBackendVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BackendVariable 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBackendVariable(node: unknown): asserts node is BackendVariable;
/**
 * 严格断言为 FrontendVariable 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFrontendVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendVariable 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFrontendVariable(node: unknown): asserts node is FrontendVariable;
/**
 * 严格断言为 Constant 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConstant(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Constant 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Function 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFunction(node: unknown): asserts node is Function;
/**
 * 严格断言为 AnonymousFunction 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAnonymousFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnonymousFunction 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAnonymousFunction(node: unknown): asserts node is AnonymousFunction;
/**
 * 严格断言为 RetryConfig 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictRetryConfig(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 RetryConfig 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictRetryConfig(node: unknown): asserts node is RetryConfig;
/**
 * 严格断言为 Interface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictInterface(node: unknown): asserts node is Interface;
/**
 * 严格断言为 McpInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMcpInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 McpInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMcpInterface(node: unknown): asserts node is McpInterface;
/**
 * 严格断言为 ConnectionInfo 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnectionInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectionInfo 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnectionInfo(node: unknown): asserts node is ConnectionInfo;
/**
 * 严格断言为 MicroserviceInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMicroserviceInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MicroserviceInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMicroserviceInterface(node: unknown): asserts node is MicroserviceInterface;
/**
 * 严格断言为 GatewayInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictGatewayInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 GatewayInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictGatewayInterface(node: unknown): asserts node is GatewayInterface;
/**
 * 严格断言为 InterfaceParam 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictInterfaceParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceParam 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictInterfaceParam(node: unknown): asserts node is InterfaceParam;
/**
 * 严格断言为 Transactional 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictTransactional(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Transactional 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictTransactional(node: unknown): asserts node is Transactional;
/**
 * 严格断言为 DefaultValue 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDefaultValue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DefaultValue 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDefaultValue(node: unknown): asserts node is DefaultValue;
/**
 * 严格断言为 Abort 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAbort(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Abort 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAbort(node: unknown): asserts node is Abort;
/**
 * 严格断言为 Start 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStart(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Start 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictStart(node: unknown): asserts node is Start;
/**
 * 严格断言为 End 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictEnd(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 End 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictEnd(node: unknown): asserts node is End;
/**
 * 严格断言为 IfStatement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictIfStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IfStatement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictIfStatement(node: unknown): asserts node is IfStatement;
/**
 * 严格断言为 IfExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictIfExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IfExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictIfExpression(node: unknown): asserts node is IfExpression;
/**
 * 严格断言为 SwitchStatement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSwitchStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchStatement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSwitchStatement(node: unknown): asserts node is SwitchStatement;
/**
 * 严格断言为 SwitchCase 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSwitchCase(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchCase 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSwitchCase(node: unknown): asserts node is SwitchCase;
/**
 * 严格断言为 ForEachStatement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictForEachStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ForEachStatement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictForEachStatement(node: unknown): asserts node is ForEachStatement;
/**
 * 严格断言为 WhileStatement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictWhileStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 WhileStatement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictWhileStatement(node: unknown): asserts node is WhileStatement;
/**
 * 严格断言为 Break 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBreak(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Break 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBreak(node: unknown): asserts node is Break;
/**
 * 严格断言为 Continue 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictContinue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Continue 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictContinue(node: unknown): asserts node is Continue;
/**
 * 严格断言为 Assignment 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAssignment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignment 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAssignment(node: unknown): asserts node is Assignment;
/**
 * 严格断言为 BatchAssignment 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBatchAssignment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BatchAssignment 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBatchAssignment(node: unknown): asserts node is BatchAssignment;
/**
 * 严格断言为 Comment 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictComment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Comment 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictComment(node: unknown): asserts node is Comment;
/**
 * 严格断言为 CallLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallFunction 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallFunction(node: unknown): asserts node is CallFunction;
/**
 * 严格断言为 CallInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallInterface(node: unknown): asserts node is CallInterface;
/**
 * 严格断言为 CallMicroserviceInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallMicroserviceInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallMicroserviceInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallMicroserviceInterface(node: unknown): asserts node is CallMicroserviceInterface;
/**
 * 严格断言为 CallGatewayInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallGatewayInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallGatewayInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallGatewayInterface(node: unknown): asserts node is CallGatewayInterface;
/**
 * 严格断言为 Destination 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDestination(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Destination 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDestination(node: unknown): asserts node is Destination;
/**
 * 严格断言为 ExternalDestination 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictExternalDestination(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ExternalDestination 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictExternalDestination(node: unknown): asserts node is ExternalDestination;
/**
 * 严格断言为 ValidationRule 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictValidationRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ValidationRule 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictValidationRule(node: unknown): asserts node is ValidationRule;
/**
 * 严格断言为 ValidationLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictValidationLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ValidationLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictValidationLogic(node: unknown): asserts node is ValidationLogic;
/**
 * 严格断言为 Argument 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictArgument(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Argument 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictArgument(node: unknown): asserts node is Argument;
/**
 * 严格断言为 Anchor 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAnchor(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Anchor 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAnchor(node: unknown): asserts node is Anchor;
/**
 * 严格断言为 JSBlock 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictJSBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 JSBlock 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictJSBlock(node: unknown): asserts node is JSBlock;
/**
 * 严格断言为 JavaLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictJavaLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 JavaLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictJavaLogic(node: unknown): asserts node is JavaLogic;
/**
 * 严格断言为 Block 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Block 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBlock(node: unknown): asserts node is Block;
/**
 * 严格断言为 Identifier 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictIdentifier(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Identifier 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictIdentifier(node: unknown): asserts node is Identifier;
/**
 * 严格断言为 NullLiteral 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNullLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NullLiteral 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNullLiteral(node: unknown): asserts node is NullLiteral;
/**
 * 严格断言为 BooleanLiteral 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBooleanLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BooleanLiteral 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBooleanLiteral(node: unknown): asserts node is BooleanLiteral;
/**
 * 严格断言为 StringLiteral 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStringLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringLiteral 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictStringLiteral(node: unknown): asserts node is StringLiteral;
/**
 * 严格断言为 StringInterpolation 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStringInterpolation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringInterpolation 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNumericLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumericLiteral 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNumericLiteral(node: unknown): asserts node is NumericLiteral;
/**
 * 严格断言为 BinaryExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictBinaryExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BinaryExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictBinaryExpression(node: unknown): asserts node is BinaryExpression;
/**
 * 严格断言为 VariadicExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictVariadicExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 VariadicExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictVariadicExpression(node: unknown): asserts node is VariadicExpression;
/**
 * 严格断言为 MatchCase 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMatchCase(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MatchCase 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMatchCase(node: unknown): asserts node is MatchCase;
/**
 * 严格断言为 Match 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMatch(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Match 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMatch(node: unknown): asserts node is Match;
/**
 * 严格断言为 UnaryExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictUnaryExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UnaryExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictUnaryExpression(node: unknown): asserts node is UnaryExpression;
/**
 * 严格断言为 MemberExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMemberExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MemberExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMemberExpression(node: unknown): asserts node is MemberExpression;
/**
 * 严格断言为 Unparsed 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictUnparsed(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Unparsed 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictUnparsed(node: unknown): asserts node is Unparsed;
/**
 * 严格断言为 New 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNew(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 New 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNew(node: unknown): asserts node is New;
/**
 * 严格断言为 NewComposite 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNewComposite(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewComposite 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNewComposite(node: unknown): asserts node is NewComposite;
/**
 * 严格断言为 NewStructure 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNewStructure(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewStructure 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNewStructure(node: unknown): asserts node is NewStructure;
/**
 * 严格断言为 NewList 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNewList(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewList 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNewList(node: unknown): asserts node is NewList;
/**
 * 严格断言为 NewMap 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNewMap(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewMap 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNewMap(node: unknown): asserts node is NewMap;
/**
 * 严格断言为 NewRegex 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictNewRegex(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewRegex 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictNewRegex(node: unknown): asserts node is NewRegex;
/**
 * 严格断言为 Paginate 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictPaginate(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictPaginate(node: unknown): asserts node is Paginate;
/**
 * 严格断言为 CallQueryComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallQueryComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallQueryComponent(node: unknown): asserts node is CallQueryComponent;
/**
 * 严格断言为 QuerySelectExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQuerySelectExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QuerySelectExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQuerySelectExpression(node: unknown): asserts node is QuerySelectExpression;
/**
 * 严格断言为 QueryFromExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryFromExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryFromExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryFromExpression(node: unknown): asserts node is QueryFromExpression;
/**
 * 严格断言为 QueryJoinExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryJoinExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryJoinExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryJoinExpression(node: unknown): asserts node is QueryJoinExpression;
/**
 * 严格断言为 QueryFieldExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryFieldExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryFieldExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryFieldExpression(node: unknown): asserts node is QueryFieldExpression;
/**
 * 严格断言为 QueryAggregateExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryAggregateExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryAggregateExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryAggregateExpression(node: unknown): asserts node is QueryAggregateExpression;
/**
 * 严格断言为 QueryOrderByExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryOrderByExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryOrderByExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryOrderByExpression(node: unknown): asserts node is QueryOrderByExpression;
/**
 * 严格断言为 QueryGroupByExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryGroupByExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryGroupByExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryGroupByExpression(node: unknown): asserts node is QueryGroupByExpression;
/**
 * 严格断言为 QueryLimitExpression 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictQueryLimitExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryLimitExpression 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictQueryLimitExpression(node: unknown): asserts node is QueryLimitExpression;
/**
 * 严格断言为 SqlQueryComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSqlQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SqlQueryComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSqlQueryComponent(node: unknown): asserts node is SqlQueryComponent;
/**
 * 严格断言为 OqlQueryComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictOqlQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OqlQueryComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictOqlQueryComponent(node: unknown): asserts node is OqlQueryComponent;
/**
 * 严格断言为 Process 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcess(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Process 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcess(node: unknown): asserts node is Process;
/**
 * 严格断言为 ProcessElement 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessElement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessElement 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessElement(node: unknown): asserts node is ProcessElement;
/**
 * 严格断言为 ProcessComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessComponent(node: unknown): asserts node is ProcessComponent;
/**
 * 严格断言为 SequentialPolicy 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSequentialPolicy(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
/**
 * 严格断言为 CountersignPolicy 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCountersignPolicy(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
/**
 * 严格断言为 ProcessOutcome 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessOutcome(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessOutcome(node: unknown): asserts node is ProcessOutcome;
/**
 * 严格断言为 Assignee 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAssignee(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAssignee(node: unknown): asserts node is Assignee;
/**
 * 严格断言为 ProcessOutcomes 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessOutcomes(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
/**
 * 严格断言为 Role 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictRole(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Role 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictRole(node: unknown): asserts node is Role;
/**
 * 严格断言为 Configuration 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConfiguration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Configuration 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConfiguration(node: unknown): asserts node is Configuration;
/**
 * 严格断言为 ConfigGroup 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConfigGroup(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigGroup 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConfigGroup(node: unknown): asserts node is ConfigGroup;
/**
 * 严格断言为 ConfigProperty 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConfigProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigProperty 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConfigProperty(node: unknown): asserts node is ConfigProperty;
/**
 * 严格断言为 ConfigPropertyValue 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConfigPropertyValue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigPropertyValue 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConfigPropertyValue(node: unknown): asserts node is ConfigPropertyValue;
/**
 * 严格断言为 I18nInfo 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictI18nInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 I18nInfo 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictI18nInfo(node: unknown): asserts node is I18nInfo;
/**
 * 严格断言为 StyleInfo 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictStyleInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StyleInfo 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictStyleInfo(node: unknown): asserts node is StyleInfo;
/**
 * 严格断言为 CompletionProperty 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCompletionProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CompletionProperty 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCompletionProperty(node: unknown): asserts node is CompletionProperty;
/**
 * 严格断言为 UseComponent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictUseComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UseComponent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictUseComponent(node: unknown): asserts node is UseComponent;
/**
 * 严格断言为 Point 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictPoint(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Point 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictPoint(node: unknown): asserts node is Point;
/**
 * 严格断言为 Rect 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictRect(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Rect 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictRect(node: unknown): asserts node is Rect;
/**
 * 严格断言为 SelectMembers 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSelectMembers(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SelectMembers 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSelectMembers(node: unknown): asserts node is SelectMembers;
/**
 * 严格断言为 AssignmentLine 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAssignmentLine(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AssignmentLine 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAssignmentLine(node: unknown): asserts node is AssignmentLine;
/**
 * 严格断言为 FrontendLibrary 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFrontendLibrary(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendLibrary 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFrontendLibrary(node: unknown): asserts node is FrontendLibrary;
/**
 * 严格断言为 ViewBlock 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictViewBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlock 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAuthInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAuthInterface(node: unknown): asserts node is AuthInterface;
/**
 * 严格断言为 CallAuthInterface 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallAuthInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallAuthInterface 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallAuthInterface(node: unknown): asserts node is CallAuthInterface;
/**
 * 严格断言为 MsgTriggerEvent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMsgTriggerEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent;
/**
 * 严格断言为 InterfaceTriggerEvent 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictInterfaceTriggerEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent;
/**
 * 严格断言为 ConnectorTrigger 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnectorTrigger(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTrigger 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnectorTrigger(node: unknown): asserts node is ConnectorTrigger;
/**
 * 严格断言为 TriggerLauncher 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TriggerLauncher 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictTriggerLauncher(node: unknown): asserts node is TriggerLauncher;
/**
 * 严格断言为 ConnectorTriggerLauncher 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnectorTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnectorTriggerLauncher(node: unknown): asserts node is ConnectorTriggerLauncher;
/**
 * 严格断言为 MsgTriggerLauncher 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictMsgTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerLauncher 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictMsgTriggerLauncher(node: unknown): asserts node is MsgTriggerLauncher;
/**
 * 严格断言为 Dependency 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDependency(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Dependency 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDependency(node: unknown): asserts node is Dependency;
/**
 * 严格断言为 Connector 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnector(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Connector 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnector(node: unknown): asserts node is Connector;
/**
 * 严格断言为 CallConnector 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCallConnector(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallConnector 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCallConnector(node: unknown): asserts node is CallConnector;
/**
 * 严格断言为 Connection 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnection(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Connection 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnection(node: unknown): asserts node is Connection;
/**
 * 严格断言为 ConnectorLogic 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictConnectorLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictConnectorLogic(node: unknown): asserts node is ConnectorLogic;
/**
 * 严格断言为 ProcessV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessV2(node: unknown): asserts node is ProcessV2;
/**
 * 严格断言为 ProcessDefinitionV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessDefinitionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessDefinitionV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessDefinitionV2(node: unknown): asserts node is ProcessDefinitionV2;
/**
 * 严格断言为 HistoryProcessV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictHistoryProcessV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 HistoryProcessV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictHistoryProcessV2(node: unknown): asserts node is HistoryProcessV2;
/**
 * 严格断言为 ProcessBindV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessBindV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessBindV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessBindV2(node: unknown): asserts node is ProcessBindV2;
/**
 * 严格断言为 FieldPermissionV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFieldPermissionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FieldPermissionV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFieldPermissionV2(node: unknown): asserts node is FieldPermissionV2;
/**
 * 严格断言为 ProcessElementV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictProcessElementV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessElementV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictProcessElementV2(node: unknown): asserts node is ProcessElementV2;
/**
 * 严格断言为 SubProcessDataMappingRule 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSubProcessDataMappingRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubProcessDataMappingRule 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSubProcessDataMappingRule(node: unknown): asserts node is SubProcessDataMappingRule;
/**
 * 严格断言为 OperatePermissionV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictOperatePermissionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OperatePermissionV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictOperatePermissionV2(node: unknown): asserts node is OperatePermissionV2;
/**
 * 严格断言为 AssigneeV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAssigneeV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AssigneeV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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;
/**
 * 严格断言为 UserAssignees 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictUserAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UserAssignees 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictUserAssignees(node: unknown): asserts node is UserAssignees;
/**
 * 严格断言为 RoleAssignees 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictRoleAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 RoleAssignees 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictRoleAssignees(node: unknown): asserts node is RoleAssignees;
/**
 * 严格断言为 DepartmentAssignees 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictDepartmentAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentAssignees 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictDepartmentAssignees(node: unknown): asserts node is DepartmentAssignees;
/**
 * 严格断言为 FlowConditionV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictFlowConditionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FlowConditionV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictFlowConditionV2(node: unknown): asserts node is FlowConditionV2;
/**
 * 严格断言为 SequentialPolicyV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictSequentialPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicyV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictSequentialPolicyV2(node: unknown): asserts node is SequentialPolicyV2;
/**
 * 严格断言为 CountersignPolicyV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictCountersignPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicyV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictCountersignPolicyV2(node: unknown): asserts node is CountersignPolicyV2;
/**
 * 严格断言为 OrSignPolicyV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictOrSignPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OrSignPolicyV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictOrSignPolicyV2(node: unknown): asserts node is OrSignPolicyV2;
/**
 * 严格断言为 AutoApproveUnmannedV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAutoApproveUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AutoApproveUnmannedV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAutoApproveUnmannedV2(node: unknown): asserts node is AutoApproveUnmannedV2;
/**
 * 严格断言为 AutoRejectUnmannedV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictAutoRejectUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AutoRejectUnmannedV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictAutoRejectUnmannedV2(node: unknown): asserts node is AutoRejectUnmannedV2;
/**
 * 严格断言为 ReassignUnmannedV2 节点
 *
 * @description 仅断言节点本身，不包含继承类
 * @example
 * ```ts
 * assertStrictReassignUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ReassignUnmannedV2 类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStrictReassignUnmannedV2(node: unknown): asserts node is ReassignUnmannedV2;
/**
 * 断言为 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 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictApp`方法
 * @example
 * ```ts
 * assertApp(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 App 或者 App 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertApp(node: unknown): asserts node is App;
/**
 * 断言为 Module 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictModule`方法
 * @example
 * ```ts
 * assertModule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Module 或者 Module 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertModule(node: unknown): asserts node is types.ModuleNode;
/**
 * 断言为 Namespace 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNamespace`方法
 * @example
 * ```ts
 * assertNamespace(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Namespace 或者 Namespace 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNamespace(node: unknown): asserts node is Namespace;
/**
 * 断言为 Directory 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDirectory`方法
 * @example
 * ```ts
 * assertDirectory(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Directory 或者 Directory 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDirectory(node: unknown): asserts node is Directory;
/**
 * 断言为 ReferredDefinition 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictReferredDefinition`方法
 * @example
 * ```ts
 * assertReferredDefinition(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ReferredDefinition 或者 ReferredDefinition 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertReferredDefinition(node: unknown): asserts node is ReferredDefinition;
/**
 * 断言为 FrontendType 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFrontendType`方法
 * @example
 * ```ts
 * assertFrontendType(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 或者 FrontendType 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFrontendType(node: unknown): asserts node is FrontendType;
/**
 * 断言为 Frontend 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFrontend`方法
 * @example
 * ```ts
 * assertFrontend(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Frontend 或者 Frontend 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFrontend(node: unknown): asserts node is Frontend;
/**
 * 断言为 Backend 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBackend`方法
 * @example
 * ```ts
 * assertBackend(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Backend 或者 Backend 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBackend(node: unknown): asserts node is Backend;
/**
 * 断言为 Integration 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictIntegration`方法
 * @example
 * ```ts
 * assertIntegration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Integration 或者 Integration 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertIntegration(node: unknown): asserts node is Integration;
/**
 * 断言为 MicroApp 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMicroApp`方法
 * @example
 * ```ts
 * assertMicroApp(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MicroApp 或者 MicroApp 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMicroApp(node: unknown): asserts node is MicroApp;
/**
 * 断言为 TypeAnnotation 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTypeAnnotation`方法
 * @example
 * ```ts
 * assertTypeAnnotation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TypeAnnotation 或者 TypeAnnotation 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTypeAnnotation(node: unknown): asserts node is TypeAnnotation;
/**
 * 断言为 DatabaseTypeAnnotation 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDatabaseTypeAnnotation`方法
 * @example
 * ```ts
 * assertDatabaseTypeAnnotation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DatabaseTypeAnnotation 或者 DatabaseTypeAnnotation 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDatabaseTypeAnnotation(node: unknown): asserts node is DatabaseTypeAnnotation;
/**
 * 断言为 TypeParam 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTypeParam`方法
 * @example
 * ```ts
 * assertTypeParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TypeParam 或者 TypeParam 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTypeParam(node: unknown): asserts node is TypeParam;
/**
 * 断言为 Structure 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStructure`方法
 * @example
 * ```ts
 * assertStructure(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Structure 或者 Structure 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStructure(node: unknown): asserts node is Structure;
/**
 * 断言为 StructureProperty 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStructureProperty`方法
 * @example
 * ```ts
 * assertStructureProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StructureProperty 或者 StructureProperty 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStructureProperty(node: unknown): asserts node is StructureProperty;
/**
 * 断言为 Enum 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEnum`方法
 * @example
 * ```ts
 * assertEnum(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Enum 或者 Enum 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEnum(node: unknown): asserts node is Enum;
/**
 * 断言为 EnumItem 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEnumItem`方法
 * @example
 * ```ts
 * assertEnumItem(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EnumItem 或者 EnumItem 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEnumItem(node: unknown): asserts node is EnumItem;
/**
 * 断言为 DataSource 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDataSource`方法
 * @example
 * ```ts
 * assertDataSource(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DataSource 或者 DataSource 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDataSource(node: unknown): asserts node is DataSource;
/**
 * 断言为 Entity 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEntity`方法
 * @example
 * ```ts
 * assertEntity(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Entity 或者 Entity 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEntity(node: unknown): asserts node is Entity;
/**
 * 断言为 EntityProperty 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEntityProperty`方法
 * @example
 * ```ts
 * assertEntityProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityProperty 或者 EntityProperty 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEntityProperty(node: unknown): asserts node is EntityProperty;
/**
 * 断言为 EntityIndex 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEntityIndex`方法
 * @example
 * ```ts
 * assertEntityIndex(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EntityIndex 或者 EntityIndex 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEntityIndex(node: unknown): asserts node is EntityIndex;
/**
 * 断言为 MetadataType 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMetadataType`方法
 * @example
 * ```ts
 * assertMetadataType(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MetadataType 或者 MetadataType 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMetadataType(node: unknown): asserts node is MetadataType;
/**
 * 断言为 View 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictView`方法
 * @example
 * ```ts
 * assertView(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 View 或者 View 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertView(node: unknown): asserts node is View;
/**
 * 断言为 ViewElement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictViewElement`方法
 * @example
 * ```ts
 * assertViewElement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewElement 或者 ViewElement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertViewElement(node: unknown): asserts node is ViewElement;
/**
 * 断言为 BindAttribute 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBindAttribute`方法
 * @example
 * ```ts
 * assertBindAttribute(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindAttribute 或者 BindAttribute 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBindAttribute(node: unknown): asserts node is BindAttribute;
/**
 * 断言为 BindDirective 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBindDirective`方法
 * @example
 * ```ts
 * assertBindDirective(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindDirective 或者 BindDirective 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBindDirective(node: unknown): asserts node is BindDirective;
/**
 * 断言为 BindEvent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBindEvent`方法
 * @example
 * ```ts
 * assertBindEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindEvent 或者 BindEvent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBindEvent(node: unknown): asserts node is BindEvent;
/**
 * 断言为 BindStyle 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBindStyle`方法
 * @example
 * ```ts
 * assertBindStyle(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BindStyle 或者 BindStyle 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBindStyle(node: unknown): asserts node is BindStyle;
/**
 * 断言为 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;
/**
 * 断言为 CustomSetter 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCustomSetter`方法
 * @example
 * ```ts
 * assertCustomSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CustomSetter 或者 CustomSetter 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCustomSetter(node: unknown): asserts node is CustomSetter;
/**
 * 断言为 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;
/**
 * 断言为 PropertyTransformSetter 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictPropertyTransformSetter`方法
 * @example
 * ```ts
 * assertPropertyTransformSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropertyTransformSetter 或者 PropertyTransformSetter 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertPropertyTransformSetter(node: unknown): asserts node is PropertyTransformSetter;
/**
 * 断言为 AnonymousFunctionSetter 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAnonymousFunctionSetter`方法
 * @example
 * ```ts
 * assertAnonymousFunctionSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnonymousFunctionSetter 或者 AnonymousFunctionSetter 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAnonymousFunctionSetter(node: unknown): asserts node is AnonymousFunctionSetter;
/**
 * 断言为 DataSourceSetter 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDataSourceSetter`方法
 * @example
 * ```ts
 * assertDataSourceSetter(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DataSourceSetter 或者 DataSourceSetter 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDataSourceSetter(node: unknown): asserts node is DataSourceSetter;
/**
 * 断言为 ViewComponentDeclaration 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictViewComponentDeclaration`方法
 * @example
 * ```ts
 * assertViewComponentDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponentDeclaration 或者 ViewComponentDeclaration 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertViewComponentDeclaration(node: unknown): asserts node is ViewComponentDeclaration;
/**
 * 断言为 BusinessComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBusinessComponent`方法
 * @example
 * ```ts
 * assertBusinessComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 或者 BusinessComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBusinessComponent(node: unknown): asserts node is BusinessComponent;
/**
 * 断言为 Attribute 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAttribute`方法
 * @example
 * ```ts
 * assertAttribute(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Attribute 或者 Attribute 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAttribute(node: unknown): asserts node is Attribute;
/**
 * 断言为 Event 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEvent`方法
 * @example
 * ```ts
 * assertEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Event 或者 Event 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEvent(node: unknown): asserts node is Event;
/**
 * 断言为 PropDeclaration 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictPropDeclaration`方法
 * @example
 * ```ts
 * assertPropDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PropDeclaration 或者 PropDeclaration 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertPropDeclaration(node: unknown): asserts node is PropDeclaration;
/**
 * 断言为 EventDeclaration 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEventDeclaration`方法
 * @example
 * ```ts
 * assertEventDeclaration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 EventDeclaration 或者 EventDeclaration 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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;
/**
 * 断言为 CSSRule 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCSSRule`方法
 * @example
 * ```ts
 * assertCSSRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CSSRule 或者 CSSRule 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCSSRule(node: unknown): asserts node is CSSRule;
/**
 * 断言为 Theme 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTheme`方法
 * @example
 * ```ts
 * assertTheme(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Theme 或者 Theme 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTheme(node: unknown): asserts node is Theme;
/**
 * 断言为 Slot 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSlot`方法
 * @example
 * ```ts
 * assertSlot(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Slot 或者 Slot 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSlot(node: unknown): asserts node is Slot;
/**
 * 断言为 ViewComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictViewComponent`方法
 * @example
 * ```ts
 * assertViewComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewComponent 或者 ViewComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertViewComponent(node: unknown): asserts node is ViewComponent;
/**
 * 断言为 Logic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictLogic`方法
 * @example
 * ```ts
 * assertLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Logic 或者 Logic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertLogic(node: unknown): asserts node is types.LogicNode;
/**
 * 断言为 SharedScope 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSharedScope`方法
 * @example
 * ```ts
 * assertSharedScope(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SharedScope 或者 SharedScope 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSharedScope(node: unknown): asserts node is types.SharedScopeNode;
/**
 * 断言为 PermissionForSharedScope 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictPermissionForSharedScope`方法
 * @example
 * ```ts
 * assertPermissionForSharedScope(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 PermissionForSharedScope 或者 PermissionForSharedScope 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertPermissionForSharedScope(node: unknown): asserts node is PermissionForSharedScope;
/**
 * 断言为 AuthLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAuthLogic`方法
 * @example
 * ```ts
 * assertAuthLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogic 或者 AuthLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAuthLogic(node: unknown): asserts node is types.AuthLogicNode;
/**
 * 断言为 AuthLogicForCallInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAuthLogicForCallInterface`方法
 * @example
 * ```ts
 * assertAuthLogicForCallInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthLogicForCallInterface 或者 AuthLogicForCallInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAuthLogicForCallInterface(node: unknown): asserts node is AuthLogicForCallInterface;
/**
 * 断言为 OverriddenLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictOverriddenLogic`方法
 * @example
 * ```ts
 * assertOverriddenLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OverriddenLogic 或者 OverriddenLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAbstractInterface`方法
 * @example
 * ```ts
 * assertAbstractInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AbstractInterface 或者 AbstractInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAbstractInterface(node: unknown): asserts node is types.AbstractInterfaceNode;
/**
 * 断言为 Param 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictParam`方法
 * @example
 * ```ts
 * assertParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Param 或者 Param 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertParam(node: unknown): asserts node is types.ParamNode;
/**
 * 断言为 ParamWithGroup 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictParamWithGroup`方法
 * @example
 * ```ts
 * assertParamWithGroup(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 或者 ParamWithGroup 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertParamWithGroup(node: unknown): asserts node is ParamWithGroup;
/**
 * 断言为 Return 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictReturn`方法
 * @example
 * ```ts
 * assertReturn(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Return 或者 Return 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertReturn(node: unknown): asserts node is Return;
/**
 * 断言为 Variable 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictVariable`方法
 * @example
 * ```ts
 * assertVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Variable 或者 Variable 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertVariable(node: unknown): asserts node is types.VariableNode;
/**
 * 断言为 BackendVariable 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBackendVariable`方法
 * @example
 * ```ts
 * assertBackendVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BackendVariable 或者 BackendVariable 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBackendVariable(node: unknown): asserts node is BackendVariable;
/**
 * 断言为 FrontendVariable 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFrontendVariable`方法
 * @example
 * ```ts
 * assertFrontendVariable(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendVariable 或者 FrontendVariable 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFrontendVariable(node: unknown): asserts node is FrontendVariable;
/**
 * 断言为 Constant 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConstant`方法
 * @example
 * ```ts
 * assertConstant(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Constant 或者 Constant 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConstant(node: unknown): asserts node is Constant;
/**
 * 断言为 LogicItem 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictLogicItem`方法
 * @example
 * ```ts
 * assertLogicItem(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 LogicItem 或者 LogicItem 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFunction`方法
 * @example
 * ```ts
 * assertFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Function 或者 Function 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFunction(node: unknown): asserts node is Function;
/**
 * 断言为 AnonymousFunction 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAnonymousFunction`方法
 * @example
 * ```ts
 * assertAnonymousFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AnonymousFunction 或者 AnonymousFunction 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAnonymousFunction(node: unknown): asserts node is AnonymousFunction;
/**
 * 断言为 ImportedInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictImportedInterface`方法
 * @example
 * ```ts
 * assertImportedInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ImportedInterface 或者 ImportedInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertImportedInterface(node: unknown): asserts node is types.ImportedInterfaceNode;
/**
 * 断言为 RetryConfig 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictRetryConfig`方法
 * @example
 * ```ts
 * assertRetryConfig(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 RetryConfig 或者 RetryConfig 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertRetryConfig(node: unknown): asserts node is RetryConfig;
/**
 * 断言为 Interface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictInterface`方法
 * @example
 * ```ts
 * assertInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Interface 或者 Interface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertInterface(node: unknown): asserts node is types.InterfaceNode;
/**
 * 断言为 McpInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMcpInterface`方法
 * @example
 * ```ts
 * assertMcpInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 McpInterface 或者 McpInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMcpInterface(node: unknown): asserts node is McpInterface;
/**
 * 断言为 ConnectionInfo 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnectionInfo`方法
 * @example
 * ```ts
 * assertConnectionInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectionInfo 或者 ConnectionInfo 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnectionInfo(node: unknown): asserts node is ConnectionInfo;
/**
 * 断言为 MicroserviceInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMicroserviceInterface`方法
 * @example
 * ```ts
 * assertMicroserviceInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MicroserviceInterface 或者 MicroserviceInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMicroserviceInterface(node: unknown): asserts node is MicroserviceInterface;
/**
 * 断言为 GatewayInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictGatewayInterface`方法
 * @example
 * ```ts
 * assertGatewayInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 GatewayInterface 或者 GatewayInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertGatewayInterface(node: unknown): asserts node is GatewayInterface;
/**
 * 断言为 InterfaceParam 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictInterfaceParam`方法
 * @example
 * ```ts
 * assertInterfaceParam(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceParam 或者 InterfaceParam 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertInterfaceParam(node: unknown): asserts node is InterfaceParam;
/**
 * 断言为 Transactional 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTransactional`方法
 * @example
 * ```ts
 * assertTransactional(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Transactional 或者 Transactional 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTransactional(node: unknown): asserts node is Transactional;
/**
 * 断言为 DefaultValue 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDefaultValue`方法
 * @example
 * ```ts
 * assertDefaultValue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DefaultValue 或者 DefaultValue 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDefaultValue(node: unknown): asserts node is DefaultValue;
/**
 * 断言为 Abort 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAbort`方法
 * @example
 * ```ts
 * assertAbort(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Abort 或者 Abort 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAbort(node: unknown): asserts node is Abort;
/**
 * 断言为 Start 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStart`方法
 * @example
 * ```ts
 * assertStart(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Start 或者 Start 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStart(node: unknown): asserts node is Start;
/**
 * 断言为 End 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictEnd`方法
 * @example
 * ```ts
 * assertEnd(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 End 或者 End 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertEnd(node: unknown): asserts node is End;
/**
 * 断言为 IfStatement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictIfStatement`方法
 * @example
 * ```ts
 * assertIfStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 IfStatement 或者 IfStatement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertIfStatement(node: unknown): asserts node is IfStatement;
/**
 * 判断输入为 IfExpression 节点实例
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 等价于`instanceof`运算，IfExpression 节点没有继承类，此判断等价于`isStrictIfExpression`
 * @example
 * ```ts
 * if (isIfExpression(node)) {
 *   // 在这个花括号内，node 的类型是 IfExpression 或者 IfExpression 继承类型
 * }
 * ```
 */
export declare function isIfExpression(node: unknown): node is IfExpression;
/**
 * 断言为 SwitchStatement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSwitchStatement`方法
 * @example
 * ```ts
 * assertSwitchStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchStatement 或者 SwitchStatement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSwitchStatement(node: unknown): asserts node is SwitchStatement;
/**
 * 断言为 SwitchCase 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSwitchCase`方法
 * @example
 * ```ts
 * assertSwitchCase(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SwitchCase 或者 SwitchCase 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSwitchCase(node: unknown): asserts node is SwitchCase;
/**
 * 断言为 ForEachStatement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictForEachStatement`方法
 * @example
 * ```ts
 * assertForEachStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ForEachStatement 或者 ForEachStatement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertForEachStatement(node: unknown): asserts node is ForEachStatement;
/**
 * 断言为 WhileStatement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictWhileStatement`方法
 * @example
 * ```ts
 * assertWhileStatement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 WhileStatement 或者 WhileStatement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertWhileStatement(node: unknown): asserts node is WhileStatement;
/**
 * 断言为 Break 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBreak`方法
 * @example
 * ```ts
 * assertBreak(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Break 或者 Break 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBreak(node: unknown): asserts node is Break;
/**
 * 断言为 Continue 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictContinue`方法
 * @example
 * ```ts
 * assertContinue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Continue 或者 Continue 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertContinue(node: unknown): asserts node is Continue;
/**
 * 断言为 Assignment 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAssignment`方法
 * @example
 * ```ts
 * assertAssignment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignment 或者 Assignment 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAssignment(node: unknown): asserts node is Assignment;
/**
 * 断言为 BatchAssignment 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBatchAssignment`方法
 * @example
 * ```ts
 * assertBatchAssignment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BatchAssignment 或者 BatchAssignment 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBatchAssignment(node: unknown): asserts node is BatchAssignment;
/**
 * 断言为 Comment 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictComment`方法
 * @example
 * ```ts
 * assertComment(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Comment 或者 Comment 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertComment(node: unknown): asserts node is Comment;
/**
 * 断言为 CallLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallLogic`方法
 * @example
 * ```ts
 * assertCallLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallLogic 或者 CallLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallLogic(node: unknown): asserts node is types.CallLogicNode;
/**
 * 断言为 CallEvent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallEvent`方法
 * @example
 * ```ts
 * assertCallEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 或者 CallEvent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallEvent(node: unknown): asserts node is CallEvent;
/**
 * 断言为 CallFunction 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallFunction`方法
 * @example
 * ```ts
 * assertCallFunction(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallFunction 或者 CallFunction 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallFunction(node: unknown): asserts node is CallFunction;
/**
 * 断言为 CallInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallInterface`方法
 * @example
 * ```ts
 * assertCallInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallInterface 或者 CallInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallInterface(node: unknown): asserts node is types.CallInterfaceNode;
/**
 * 断言为 CallMicroserviceInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallMicroserviceInterface`方法
 * @example
 * ```ts
 * assertCallMicroserviceInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallMicroserviceInterface 或者 CallMicroserviceInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallMicroserviceInterface(node: unknown): asserts node is CallMicroserviceInterface;
/**
 * 断言为 CallGatewayInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallGatewayInterface`方法
 * @example
 * ```ts
 * assertCallGatewayInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallGatewayInterface 或者 CallGatewayInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallGatewayInterface(node: unknown): asserts node is CallGatewayInterface;
/**
 * 断言为 Destination 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDestination`方法
 * @example
 * ```ts
 * assertDestination(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Destination 或者 Destination 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDestination(node: unknown): asserts node is Destination;
/**
 * 断言为 ExternalDestination 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictExternalDestination`方法
 * @example
 * ```ts
 * assertExternalDestination(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ExternalDestination 或者 ExternalDestination 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertExternalDestination(node: unknown): asserts node is ExternalDestination;
/**
 * 断言为 AbstractValidation 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAbstractValidation`方法
 * @example
 * ```ts
 * assertAbstractValidation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AbstractValidation 或者 AbstractValidation 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAbstractValidation(node: unknown): asserts node is types.AbstractValidationNode;
/**
 * 断言为 ValidationRule 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictValidationRule`方法
 * @example
 * ```ts
 * assertValidationRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ValidationRule 或者 ValidationRule 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertValidationRule(node: unknown): asserts node is ValidationRule;
/**
 * 断言为 ValidationLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictValidationLogic`方法
 * @example
 * ```ts
 * assertValidationLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ValidationLogic 或者 ValidationLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertValidationLogic(node: unknown): asserts node is ValidationLogic;
/**
 * 断言为 Argument 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictArgument`方法
 * @example
 * ```ts
 * assertArgument(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Argument 或者 Argument 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertArgument(node: unknown): asserts node is Argument;
/**
 * 断言为 Anchor 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAnchor`方法
 * @example
 * ```ts
 * assertAnchor(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Anchor 或者 Anchor 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAnchor(node: unknown): asserts node is Anchor;
/**
 * 断言为 JSBlock 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictJSBlock`方法
 * @example
 * ```ts
 * assertJSBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 JSBlock 或者 JSBlock 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertJSBlock(node: unknown): asserts node is JSBlock;
/**
 * 断言为 JavaLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictJavaLogic`方法
 * @example
 * ```ts
 * assertJavaLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 JavaLogic 或者 JavaLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertJavaLogic(node: unknown): asserts node is JavaLogic;
/**
 * 断言为 Block 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBlock`方法
 * @example
 * ```ts
 * assertBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Block 或者 Block 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBlock(node: unknown): asserts node is Block;
/**
 * 断言为 Identifier 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictIdentifier`方法
 * @example
 * ```ts
 * assertIdentifier(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Identifier 或者 Identifier 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertIdentifier(node: unknown): asserts node is Identifier;
/**
 * 断言为 NullLiteral 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNullLiteral`方法
 * @example
 * ```ts
 * assertNullLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NullLiteral 或者 NullLiteral 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNullLiteral(node: unknown): asserts node is NullLiteral;
/**
 * 断言为 BooleanLiteral 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBooleanLiteral`方法
 * @example
 * ```ts
 * assertBooleanLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BooleanLiteral 或者 BooleanLiteral 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBooleanLiteral(node: unknown): asserts node is BooleanLiteral;
/**
 * 断言为 StringLiteral 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStringLiteral`方法
 * @example
 * ```ts
 * assertStringLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringLiteral 或者 StringLiteral 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStringLiteral(node: unknown): asserts node is StringLiteral;
/**
 * 断言为 StringInterpolation 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStringInterpolation`方法
 * @example
 * ```ts
 * assertStringInterpolation(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StringInterpolation 或者 StringInterpolation 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNumericLiteral`方法
 * @example
 * ```ts
 * assertNumericLiteral(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NumericLiteral 或者 NumericLiteral 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNumericLiteral(node: unknown): asserts node is NumericLiteral;
/**
 * 断言为 BinaryExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictBinaryExpression`方法
 * @example
 * ```ts
 * assertBinaryExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BinaryExpression 或者 BinaryExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertBinaryExpression(node: unknown): asserts node is BinaryExpression;
/**
 * 断言为 VariadicExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictVariadicExpression`方法
 * @example
 * ```ts
 * assertVariadicExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 VariadicExpression 或者 VariadicExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertVariadicExpression(node: unknown): asserts node is VariadicExpression;
/**
 * 断言为 MatchCase 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMatchCase`方法
 * @example
 * ```ts
 * assertMatchCase(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MatchCase 或者 MatchCase 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMatchCase(node: unknown): asserts node is MatchCase;
/**
 * 断言为 Match 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMatch`方法
 * @example
 * ```ts
 * assertMatch(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Match 或者 Match 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMatch(node: unknown): asserts node is Match;
/**
 * 断言为 UnaryExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictUnaryExpression`方法
 * @example
 * ```ts
 * assertUnaryExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UnaryExpression 或者 UnaryExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertUnaryExpression(node: unknown): asserts node is UnaryExpression;
/**
 * 断言为 MemberExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMemberExpression`方法
 * @example
 * ```ts
 * assertMemberExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MemberExpression 或者 MemberExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMemberExpression(node: unknown): asserts node is MemberExpression;
/**
 * 断言为 Unparsed 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictUnparsed`方法
 * @example
 * ```ts
 * assertUnparsed(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Unparsed 或者 Unparsed 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertUnparsed(node: unknown): asserts node is Unparsed;
/**
 * 断言为 New 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNew`方法
 * @example
 * ```ts
 * assertNew(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 New 或者 New 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNew(node: unknown): asserts node is New;
/**
 * 断言为 NewComposite 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNewComposite`方法
 * @example
 * ```ts
 * assertNewComposite(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewComposite 或者 NewComposite 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNewComposite(node: unknown): asserts node is NewComposite;
/**
 * 断言为 NewStructure 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNewStructure`方法
 * @example
 * ```ts
 * assertNewStructure(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewStructure 或者 NewStructure 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNewStructure(node: unknown): asserts node is NewStructure;
/**
 * 断言为 NewList 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNewList`方法
 * @example
 * ```ts
 * assertNewList(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewList 或者 NewList 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNewList(node: unknown): asserts node is NewList;
/**
 * 断言为 NewMap 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNewMap`方法
 * @example
 * ```ts
 * assertNewMap(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewMap 或者 NewMap 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNewMap(node: unknown): asserts node is NewMap;
/**
 * 断言为 NewRegex 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictNewRegex`方法
 * @example
 * ```ts
 * assertNewRegex(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 NewRegex 或者 NewRegex 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertNewRegex(node: unknown): asserts node is NewRegex;
/**
 * 断言为 Paginate 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictPaginate`方法
 * @example
 * ```ts
 * assertPaginate(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 或者 Paginate 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertPaginate(node: unknown): asserts node is Paginate;
/**
 * 断言为 CallQueryComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallQueryComponent`方法
 * @example
 * ```ts
 * assertCallQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallQueryComponent 或者 CallQueryComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallQueryComponent(node: unknown): asserts node is CallQueryComponent;
/**
 * 断言为 QuerySelectExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQuerySelectExpression`方法
 * @example
 * ```ts
 * assertQuerySelectExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QuerySelectExpression 或者 QuerySelectExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQuerySelectExpression(node: unknown): asserts node is QuerySelectExpression;
/**
 * 断言为 QueryFromExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryFromExpression`方法
 * @example
 * ```ts
 * assertQueryFromExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryFromExpression 或者 QueryFromExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryFromExpression(node: unknown): asserts node is QueryFromExpression;
/**
 * 断言为 QueryJoinExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryJoinExpression`方法
 * @example
 * ```ts
 * assertQueryJoinExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryJoinExpression 或者 QueryJoinExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryJoinExpression(node: unknown): asserts node is QueryJoinExpression;
/**
 * 断言为 QueryFieldExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryFieldExpression`方法
 * @example
 * ```ts
 * assertQueryFieldExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryFieldExpression 或者 QueryFieldExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryFieldExpression(node: unknown): asserts node is QueryFieldExpression;
/**
 * 断言为 QueryAggregateExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryAggregateExpression`方法
 * @example
 * ```ts
 * assertQueryAggregateExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryAggregateExpression 或者 QueryAggregateExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryAggregateExpression(node: unknown): asserts node is QueryAggregateExpression;
/**
 * 断言为 QueryOrderByExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryOrderByExpression`方法
 * @example
 * ```ts
 * assertQueryOrderByExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryOrderByExpression 或者 QueryOrderByExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryOrderByExpression(node: unknown): asserts node is QueryOrderByExpression;
/**
 * 断言为 QueryGroupByExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryGroupByExpression`方法
 * @example
 * ```ts
 * assertQueryGroupByExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryGroupByExpression 或者 QueryGroupByExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryGroupByExpression(node: unknown): asserts node is QueryGroupByExpression;
/**
 * 断言为 QueryLimitExpression 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictQueryLimitExpression`方法
 * @example
 * ```ts
 * assertQueryLimitExpression(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 QueryLimitExpression 或者 QueryLimitExpression 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertQueryLimitExpression(node: unknown): asserts node is QueryLimitExpression;
/**
 * 断言为 SqlQueryComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSqlQueryComponent`方法
 * @example
 * ```ts
 * assertSqlQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SqlQueryComponent 或者 SqlQueryComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSqlQueryComponent(node: unknown): asserts node is SqlQueryComponent;
/**
 * 断言为 OqlQueryComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictOqlQueryComponent`方法
 * @example
 * ```ts
 * assertOqlQueryComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OqlQueryComponent 或者 OqlQueryComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertOqlQueryComponent(node: unknown): asserts node is OqlQueryComponent;
/**
 * 断言为 Process 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcess`方法
 * @example
 * ```ts
 * assertProcess(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Process 或者 Process 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcess(node: unknown): asserts node is Process;
/**
 * 断言为 ProcessElement 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessElement`方法
 * @example
 * ```ts
 * assertProcessElement(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessElement 或者 ProcessElement 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessElement(node: unknown): asserts node is ProcessElement;
/**
 * 断言为 ProcessComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessComponent`方法
 * @example
 * ```ts
 * assertProcessComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessComponent 或者 ProcessComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessComponent(node: unknown): asserts node is ProcessComponent;
/**
 * 断言为 MultiApprovalPolicy 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMultiApprovalPolicy`方法
 * @example
 * ```ts
 * assertMultiApprovalPolicy(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MultiApprovalPolicy 或者 MultiApprovalPolicy 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMultiApprovalPolicy(node: unknown): asserts node is types.MultiApprovalPolicyNode;
/**
 * 断言为 SequentialPolicy 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSequentialPolicy`方法
 * @example
 * ```ts
 * assertSequentialPolicy(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicy 或者 SequentialPolicy 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSequentialPolicy(node: unknown): asserts node is SequentialPolicy;
/**
 * 断言为 CountersignPolicy 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCountersignPolicy`方法
 * @example
 * ```ts
 * assertCountersignPolicy(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicy 或者 CountersignPolicy 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCountersignPolicy(node: unknown): asserts node is CountersignPolicy;
/**
 * 断言为 ProcessOutcome 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessOutcome`方法
 * @example
 * ```ts
 * assertProcessOutcome(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcome 或者 ProcessOutcome 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessOutcome(node: unknown): asserts node is ProcessOutcome;
/**
 * 断言为 Assignee 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAssignee`方法
 * @example
 * ```ts
 * assertAssignee(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignee 或者 Assignee 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAssignee(node: unknown): asserts node is Assignee;
/**
 * 断言为 ProcessOutcomes 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessOutcomes`方法
 * @example
 * ```ts
 * assertProcessOutcomes(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessOutcomes 或者 ProcessOutcomes 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessOutcomes(node: unknown): asserts node is ProcessOutcomes;
/**
 * 断言为 Role 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictRole`方法
 * @example
 * ```ts
 * assertRole(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Role 或者 Role 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertRole(node: unknown): asserts node is Role;
/**
 * 断言为 Configuration 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConfiguration`方法
 * @example
 * ```ts
 * assertConfiguration(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Configuration 或者 Configuration 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConfiguration(node: unknown): asserts node is Configuration;
/**
 * 断言为 ConfigGroup 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConfigGroup`方法
 * @example
 * ```ts
 * assertConfigGroup(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigGroup 或者 ConfigGroup 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConfigGroup(node: unknown): asserts node is ConfigGroup;
/**
 * 断言为 ConfigProperty 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConfigProperty`方法
 * @example
 * ```ts
 * assertConfigProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigProperty 或者 ConfigProperty 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConfigProperty(node: unknown): asserts node is ConfigProperty;
/**
 * 断言为 ConfigPropertyValue 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConfigPropertyValue`方法
 * @example
 * ```ts
 * assertConfigPropertyValue(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConfigPropertyValue 或者 ConfigPropertyValue 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConfigPropertyValue(node: unknown): asserts node is ConfigPropertyValue;
/**
 * 断言为 I18nInfo 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictI18nInfo`方法
 * @example
 * ```ts
 * assertI18nInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 I18nInfo 或者 I18nInfo 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertI18nInfo(node: unknown): asserts node is I18nInfo;
/**
 * 断言为 StyleInfo 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictStyleInfo`方法
 * @example
 * ```ts
 * assertStyleInfo(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 StyleInfo 或者 StyleInfo 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertStyleInfo(node: unknown): asserts node is StyleInfo;
/**
 * 断言为 CompletionProperty 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCompletionProperty`方法
 * @example
 * ```ts
 * assertCompletionProperty(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CompletionProperty 或者 CompletionProperty 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCompletionProperty(node: unknown): asserts node is CompletionProperty;
/**
 * 断言为 UseComponent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictUseComponent`方法
 * @example
 * ```ts
 * assertUseComponent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UseComponent 或者 UseComponent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertUseComponent(node: unknown): asserts node is UseComponent;
/**
 * 断言为 Point 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictPoint`方法
 * @example
 * ```ts
 * assertPoint(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Point 或者 Point 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertPoint(node: unknown): asserts node is Point;
/**
 * 断言为 Rect 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictRect`方法
 * @example
 * ```ts
 * assertRect(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Rect 或者 Rect 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertRect(node: unknown): asserts node is Rect;
/**
 * 断言为 SelectMembers 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSelectMembers`方法
 * @example
 * ```ts
 * assertSelectMembers(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SelectMembers 或者 SelectMembers 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSelectMembers(node: unknown): asserts node is SelectMembers;
/**
 * 断言为 AssignmentLine 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAssignmentLine`方法
 * @example
 * ```ts
 * assertAssignmentLine(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AssignmentLine 或者 AssignmentLine 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAssignmentLine(node: unknown): asserts node is AssignmentLine;
/**
 * 断言为 FrontendLibrary 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFrontendLibrary`方法
 * @example
 * ```ts
 * assertFrontendLibrary(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendLibrary 或者 FrontendLibrary 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFrontendLibrary(node: unknown): asserts node is FrontendLibrary;
/**
 * 断言为 ViewBlock 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictViewBlock`方法
 * @example
 * ```ts
 * assertViewBlock(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ViewBlock 或者 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 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAuthInterface`方法
 * @example
 * ```ts
 * assertAuthInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AuthInterface 或者 AuthInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAuthInterface(node: unknown): asserts node is AuthInterface;
/**
 * 断言为 CallAuthInterface 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallAuthInterface`方法
 * @example
 * ```ts
 * assertCallAuthInterface(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallAuthInterface 或者 CallAuthInterface 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallAuthInterface(node: unknown): asserts node is CallAuthInterface;
/**
 * 断言为 TriggerEvent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTriggerEvent`方法
 * @example
 * ```ts
 * assertTriggerEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TriggerEvent 或者 TriggerEvent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTriggerEvent(node: unknown): asserts node is types.TriggerEventNode;
/**
 * 断言为 MsgTriggerEvent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMsgTriggerEvent`方法
 * @example
 * ```ts
 * assertMsgTriggerEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 或者 MsgTriggerEvent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent;
/**
 * 断言为 InterfaceTriggerEvent 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictInterfaceTriggerEvent`方法
 * @example
 * ```ts
 * assertInterfaceTriggerEvent(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent;
/**
 * 断言为 ConnectorTrigger 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnectorTrigger`方法
 * @example
 * ```ts
 * assertConnectorTrigger(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTrigger 或者 ConnectorTrigger 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnectorTrigger(node: unknown): asserts node is ConnectorTrigger;
/**
 * 断言为 TriggerLauncher 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictTriggerLauncher`方法
 * @example
 * ```ts
 * assertTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TriggerLauncher 或者 TriggerLauncher 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertTriggerLauncher(node: unknown): asserts node is types.TriggerLauncherNode;
/**
 * 断言为 ConnectorTriggerLauncher 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnectorTriggerLauncher`方法
 * @example
 * ```ts
 * assertConnectorTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnectorTriggerLauncher(node: unknown): asserts node is types.ConnectorTriggerLauncherNode;
/**
 * 断言为 MsgTriggerLauncher 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictMsgTriggerLauncher`方法
 * @example
 * ```ts
 * assertMsgTriggerLauncher(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerLauncher 或者 MsgTriggerLauncher 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertMsgTriggerLauncher(node: unknown): asserts node is MsgTriggerLauncher;
/**
 * 断言为 Dependency 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDependency`方法
 * @example
 * ```ts
 * assertDependency(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Dependency 或者 Dependency 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDependency(node: unknown): asserts node is Dependency;
/**
 * 断言为 Connector 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnector`方法
 * @example
 * ```ts
 * assertConnector(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Connector 或者 Connector 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnector(node: unknown): asserts node is Connector;
/**
 * 断言为 CallConnector 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCallConnector`方法
 * @example
 * ```ts
 * assertCallConnector(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallConnector 或者 CallConnector 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCallConnector(node: unknown): asserts node is CallConnector;
/**
 * 断言为 Connection 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnection`方法
 * @example
 * ```ts
 * assertConnection(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Connection 或者 Connection 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnection(node: unknown): asserts node is Connection;
/**
 * 断言为 ConnectorLogic 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictConnectorLogic`方法
 * @example
 * ```ts
 * assertConnectorLogic(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 或者 ConnectorLogic 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertConnectorLogic(node: unknown): asserts node is ConnectorLogic;
/**
 * 断言为 ProcessV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessV2`方法
 * @example
 * ```ts
 * assertProcessV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessV2 或者 ProcessV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessV2(node: unknown): asserts node is ProcessV2;
/**
 * 断言为 ProcessDefinitionV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessDefinitionV2`方法
 * @example
 * ```ts
 * assertProcessDefinitionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessDefinitionV2 或者 ProcessDefinitionV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessDefinitionV2(node: unknown): asserts node is ProcessDefinitionV2;
/**
 * 断言为 HistoryProcessV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictHistoryProcessV2`方法
 * @example
 * ```ts
 * assertHistoryProcessV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 HistoryProcessV2 或者 HistoryProcessV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertHistoryProcessV2(node: unknown): asserts node is HistoryProcessV2;
/**
 * 断言为 ProcessBindV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessBindV2`方法
 * @example
 * ```ts
 * assertProcessBindV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessBindV2 或者 ProcessBindV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessBindV2(node: unknown): asserts node is ProcessBindV2;
/**
 * 断言为 FieldPermissionV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFieldPermissionV2`方法
 * @example
 * ```ts
 * assertFieldPermissionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FieldPermissionV2 或者 FieldPermissionV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFieldPermissionV2(node: unknown): asserts node is FieldPermissionV2;
/**
 * 断言为 ProcessElementV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictProcessElementV2`方法
 * @example
 * ```ts
 * assertProcessElementV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ProcessElementV2 或者 ProcessElementV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertProcessElementV2(node: unknown): asserts node is ProcessElementV2;
/**
 * 断言为 SubProcessDataMappingRule 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSubProcessDataMappingRule`方法
 * @example
 * ```ts
 * assertSubProcessDataMappingRule(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SubProcessDataMappingRule 或者 SubProcessDataMappingRule 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSubProcessDataMappingRule(node: unknown): asserts node is SubProcessDataMappingRule;
/**
 * 断言为 OperatePermissionV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictOperatePermissionV2`方法
 * @example
 * ```ts
 * assertOperatePermissionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OperatePermissionV2 或者 OperatePermissionV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertOperatePermissionV2(node: unknown): asserts node is OperatePermissionV2;
/**
 * 断言为 AssigneeV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAssigneeV2`方法
 * @example
 * ```ts
 * assertAssigneeV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AssigneeV2 或者 AssigneeV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
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;
/**
 * 断言为 Assignees 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAssignees`方法
 * @example
 * ```ts
 * assertAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Assignees 或者 Assignees 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAssignees(node: unknown): asserts node is types.AssigneesNode;
/**
 * 断言为 UserAssignees 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictUserAssignees`方法
 * @example
 * ```ts
 * assertUserAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UserAssignees 或者 UserAssignees 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertUserAssignees(node: unknown): asserts node is UserAssignees;
/**
 * 断言为 RoleAssignees 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictRoleAssignees`方法
 * @example
 * ```ts
 * assertRoleAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 RoleAssignees 或者 RoleAssignees 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertRoleAssignees(node: unknown): asserts node is RoleAssignees;
/**
 * 断言为 DepartmentAssignees 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictDepartmentAssignees`方法
 * @example
 * ```ts
 * assertDepartmentAssignees(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 DepartmentAssignees 或者 DepartmentAssignees 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertDepartmentAssignees(node: unknown): asserts node is DepartmentAssignees;
/**
 * 断言为 FlowConditionV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictFlowConditionV2`方法
 * @example
 * ```ts
 * assertFlowConditionV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FlowConditionV2 或者 FlowConditionV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertFlowConditionV2(node: unknown): asserts node is FlowConditionV2;
/**
 * 断言为 ApprovalPolicyV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictApprovalPolicyV2`方法
 * @example
 * ```ts
 * assertApprovalPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ApprovalPolicyV2 或者 ApprovalPolicyV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertApprovalPolicyV2(node: unknown): asserts node is types.ApprovalPolicyV2Node;
/**
 * 断言为 SequentialPolicyV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictSequentialPolicyV2`方法
 * @example
 * ```ts
 * assertSequentialPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 SequentialPolicyV2 或者 SequentialPolicyV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertSequentialPolicyV2(node: unknown): asserts node is SequentialPolicyV2;
/**
 * 断言为 CountersignPolicyV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictCountersignPolicyV2`方法
 * @example
 * ```ts
 * assertCountersignPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CountersignPolicyV2 或者 CountersignPolicyV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertCountersignPolicyV2(node: unknown): asserts node is CountersignPolicyV2;
/**
 * 断言为 OrSignPolicyV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictOrSignPolicyV2`方法
 * @example
 * ```ts
 * assertOrSignPolicyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 OrSignPolicyV2 或者 OrSignPolicyV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertOrSignPolicyV2(node: unknown): asserts node is OrSignPolicyV2;
/**
 * 断言为 UnmannedApprovalStrategyV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictUnmannedApprovalStrategyV2`方法
 * @example
 * ```ts
 * assertUnmannedApprovalStrategyV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 UnmannedApprovalStrategyV2 或者 UnmannedApprovalStrategyV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertUnmannedApprovalStrategyV2(node: unknown): asserts node is types.UnmannedApprovalStrategyV2Node;
/**
 * 断言为 AutoApproveUnmannedV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAutoApproveUnmannedV2`方法
 * @example
 * ```ts
 * assertAutoApproveUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AutoApproveUnmannedV2 或者 AutoApproveUnmannedV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAutoApproveUnmannedV2(node: unknown): asserts node is AutoApproveUnmannedV2;
/**
 * 断言为 AutoRejectUnmannedV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictAutoRejectUnmannedV2`方法
 * @example
 * ```ts
 * assertAutoRejectUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 AutoRejectUnmannedV2 或者 AutoRejectUnmannedV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertAutoRejectUnmannedV2(node: unknown): asserts node is AutoRejectUnmannedV2;
/**
 * 断言为 ReassignUnmannedV2 节点
 *
 * @description 包含节点类以及节点继承类的判断
 * @description 节点没有继承类时，等价于`assertStrictReassignUnmannedV2`方法
 * @example
 * ```ts
 * assertReassignUnmannedV2(node);
 * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ReassignUnmannedV2 或者 ReassignUnmannedV2 继承类型
 * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
 * ```
 */
export declare function assertReassignUnmannedV2(node: unknown): asserts node is ReassignUnmannedV2;
//# sourceMappingURL=asserts.d.ts.map