import type { SyntaxNode } from './utils/types';
import type Frontend from './Frontend__';
import type { NaslServer } from '@lcap/nasl-types';
export interface LibInfo {
    name: string;
    version: string;
    js: string[];
    css: string[];
    used?: boolean;
}
export interface AssetsInfo {
    js: Array<string>;
    css: Array<string>;
    names?: Array<string>;
}
interface MessageData {
    logicName: string;
    param?: string;
    interfaceName?: string;
    message: string;
    type: number;
    resultName?: string;
}
type composeCacheType = {
    [key: string]: composeCacheType;
} & {
    nodes?: any[];
};
import { EventPayload } from '../common/types';
import * as types from './utils/types';
import BaseNode from '../common/BaseNode';
import type DataSource from './DataSource__';
import type Structure from './Structure__';
import type Enum from './Enum__';
import type Logic from './Logic__';
import type OverriddenLogic from './OverriddenLogic__';
import type AbstractInterface from './AbstractInterface__';
import type FrontendType from './FrontendType__';
import type Backend from './Backend__';
import type Process from './Process__';
import type ProcessV2 from './ProcessV2__';
import type Role from './Role__';
import type Configuration from './Configuration__';
import type Connector from './Connector__';
import type Module from './Module__';
import type Integration from './Integration__';
import type AuthLogic from './AuthLogic__';
import type AuthLogicForCallInterface from './AuthLogicForCallInterface__';
import type Connection from './Connection__';
import type TriggerLauncher from './TriggerLauncher__';
import type MetadataType from './MetadataType__';
import type Directory from './Directory__';
/**
 * 应用
 */
export declare class App extends BaseNode {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'App';
    /**
     * 应用 Id
     */
    id: string;
    /**
     * IDE 版本
     */
    ideVersion: string;
    /**
     * IDE 版本
     */
    createdIdeVersion: string;
    /**
     * 应用标识
     */
    name: string;
    /**
     * 应用标题
     */
    title: string;
    /**
     * 应用图标
     */
    icon: string;
    /**
     * 应用描述
     */
    desc: string;
    /**
     * 域名
     */
    dnsAddr?: string;
    /**
     * 是否有用户中心
     */
    hasUserCenter: boolean;
    /**
     * 是否有权限
     */
    hasAuth: boolean;
    /**
     * 数据源列表
     */
    dataSources: Array<DataSource>;
    /**
     * 数据结构列表
     */
    structures: Array<Structure>;
    /**
     * 枚举列表
     */
    enums: Array<Enum>;
    /**
     * 逻辑列表
     */
    logics: Array<Logic>;
    /**
     * 覆写逻辑列表
     */
    overriddenLogics: Array<OverriddenLogic>;
    /**
     * 接口列表
     */
    interfaces: Array<types.AbstractInterfaceNode>;
    /**
     * 端类型列表
     */
    frontendTypes: Array<FrontendType>;
    /**
     * 后端
     */
    backend: Backend;
    /**
     * 流程列表
     */
    processes: Array<Process>;
    /**
     * 流程列表
     */
    processV2s: Array<ProcessV2>;
    /**
     * 角色列表
     */
    roles: Array<Role>;
    /**
     * 配置管理
     */
    configuration: Configuration;
    /**
     * 连接器列表
     */
    connectorDependencies: Array<Connector>;
    /**
     * 接口应用列表（兼容老版）
     */
    interfaceDependencies: Array<Module>;
    /**
     * 共享应用模块
     */
    sharedAppDependencies: Array<Module>;
    /**
     * 扩展模块列表
     */
    dependencies: Array<Module>;
    /**
     * 集成
     */
    integration?: Integration;
    /**
     * 暴露接口的接口鉴权
     */
    authLogics: Array<AuthLogic>;
    /**
     * 调用接口的鉴权模板
     */
    authLogicsForCallInterface: Array<AuthLogicForCallInterface>;
    /**
     * 连接
     */
    connections: Array<Connection>;
    /**
     * 触发器启动器
     */
    triggerLaunchers: Array<TriggerLauncher>;
    /**
     * 元数据类型列表
     */
    metadataTypes: Array<MetadataType>;
    /**
     * 偏好设置
     */
    preferenceMap: Record<string, string>;
    /**
     * 文件夹列表
     */
    directories: Array<Directory>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<App>);
    static from(source: any, parentNode?: any, parentKey?: string): App;
    /**
     * 设置集成
     */
    setIntegration(integration: Integration): void;
    getDataSourceUniqueName(name?: string): string;
    /**
     * 插入数据源
     * @internal
     * @param name 数据源名称，如果不填会自动生成一个唯一名称
     */
    _insertDataSourceAt(name: string, index: number): DataSource;
    /**
     * 插入数据源
     * @internal
     * @param dataSourceOptions 数据源参数
     */
    _insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
    /**
     * 插入数据源
     * @internal
     * @param dataSource 已有的数据源实例
     */
    _insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
    /**
     * 插入数据源
     * @param name 数据源名称，如果不填会自动生成一个唯一名称
     */
    insertDataSourceAt(name: string, index: number): DataSource;
    /**
     * 插入数据源
     * @param dataSourceOptions 数据源参数
     */
    insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
    /**
     * 插入数据源
     * @param dataSource 已有的数据源实例
     */
    insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
    /**
     * 添加数据源
     * @internal
     * @param name 数据源名称，如果不填会自动生成一个唯一名称
     */
    _addDataSource(name?: string): DataSource;
    /**
     * 添加数据源
     * @internal
     * @param dataSourceOptions 数据源参数
     */
    _addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
    /**
     * 添加数据源
     * @internal
     * @param dataSource 已有的数据源实例
     */
    _addDataSource(dataSource: DataSource): DataSource;
    /**
     * 添加数据源
     * @internal
     * @param name 数据源名称，如果不填会自动生成一个唯一名称
     */
    addDataSource(name?: string): DataSource;
    /**
     * 添加数据源
     * @param dataSourceOptions 数据源参数
     */
    addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
    /**
     * 添加数据源
     * @param dataSource 已有的数据源实例
     */
    addDataSource(dataSource: DataSource): DataSource;
    getStructureExistingNames(excludedList?: Array<Structure>): string[];
    getStructureUniqueName(name?: string): string;
    /**
     * 插入数据结构
     * @internal
     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
     */
    _insertStructureAt(name: string, index: number): Structure;
    /**
     * 插入数据结构
     * @internal
     * @param structureOptions 数据结构参数
     */
    _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
    /**
     * 插入数据结构
     * @internal
     * @param structure 已有的数据结构实例
     */
    _insertStructureAt(structure: Structure, index: number): Structure;
    /**
     * 插入数据结构
     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
     */
    insertStructureAt(name: string, index: number): Structure;
    /**
     * 插入数据结构
     * @param structureOptions 数据结构参数
     */
    insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
    /**
     * 插入数据结构
     * @param structure 已有的数据结构实例
     */
    insertStructureAt(structure: Structure, index: number): Structure;
    /**
     * 添加数据结构
     * @internal
     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
     */
    _addStructure(name?: string): Structure;
    /**
     * 添加数据结构
     * @internal
     * @param structureOptions 数据结构参数
     */
    _addStructure(structureOptions: Partial<Structure>): Structure;
    /**
     * 添加数据结构
     * @internal
     * @param structure 已有的数据结构实例
     */
    _addStructure(structure: Structure): Structure;
    /**
     * 添加数据结构
     * @internal
     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
     */
    addStructure(name?: string): Structure;
    /**
     * 添加数据结构
     * @param structureOptions 数据结构参数
     */
    addStructure(structureOptions: Partial<Structure>): Structure;
    /**
     * 添加数据结构
     * @param structure 已有的数据结构实例
     */
    addStructure(structure: Structure): Structure;
    getEnumExistingNames(excludedList?: Array<Enum>): string[];
    getEnumUniqueName(name?: string): string;
    /**
     * 插入枚举
     * @internal
     * @param name 枚举名称，如果不填会自动生成一个唯一名称
     */
    _insertEnumAt(name: string, index: number): Enum;
    /**
     * 插入枚举
     * @internal
     * @param enumerationOptions 枚举参数
     */
    _insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
    /**
     * 插入枚举
     * @internal
     * @param enumeration 已有的枚举实例
     */
    _insertEnumAt(enumeration: Enum, index: number): Enum;
    /**
     * 插入枚举
     * @param name 枚举名称，如果不填会自动生成一个唯一名称
     */
    insertEnumAt(name: string, index: number): Enum;
    /**
     * 插入枚举
     * @param enumerationOptions 枚举参数
     */
    insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
    /**
     * 插入枚举
     * @param enumeration 已有的枚举实例
     */
    insertEnumAt(enumeration: Enum, index: number): Enum;
    /**
     * 添加枚举
     * @internal
     * @param name 枚举名称，如果不填会自动生成一个唯一名称
     */
    _addEnum(name?: string): Enum;
    /**
     * 添加枚举
     * @internal
     * @param enumerationOptions 枚举参数
     */
    _addEnum(enumerationOptions: Partial<Enum>): Enum;
    /**
     * 添加枚举
     * @internal
     * @param enumeration 已有的枚举实例
     */
    _addEnum(enumeration: Enum): Enum;
    /**
     * 添加枚举
     * @internal
     * @param name 枚举名称，如果不填会自动生成一个唯一名称
     */
    addEnum(name?: string): Enum;
    /**
     * 添加枚举
     * @param enumerationOptions 枚举参数
     */
    addEnum(enumerationOptions: Partial<Enum>): Enum;
    /**
     * 添加枚举
     * @param enumeration 已有的枚举实例
     */
    addEnum(enumeration: Enum): Enum;
    getLogicExistingNames(excludedList?: Array<Logic>): string[];
    getLogicUniqueName(name?: string): string;
    /**
     * 插入逻辑
     * @internal
     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
     */
    _insertLogicAt(name: string, index: number): Logic;
    /**
     * 插入逻辑
     * @internal
     * @param logicOptions 逻辑参数
     */
    _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
    /**
     * 插入逻辑
     * @internal
     * @param logic 已有的逻辑实例
     */
    _insertLogicAt(logic: Logic, index: number): Logic;
    /**
     * 插入逻辑
     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
     */
    insertLogicAt(name: string, index: number): Logic;
    /**
     * 插入逻辑
     * @param logicOptions 逻辑参数
     */
    insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
    /**
     * 插入逻辑
     * @param logic 已有的逻辑实例
     */
    insertLogicAt(logic: Logic, index: number): Logic;
    /**
     * 添加逻辑
     * @internal
     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
     */
    _addLogic(name?: string): Logic;
    /**
     * 添加逻辑
     * @internal
     * @param logicOptions 逻辑参数
     */
    _addLogic(logicOptions: Partial<Logic>): Logic;
    /**
     * 添加逻辑
     * @internal
     * @param logic 已有的逻辑实例
     */
    _addLogic(logic: Logic): Logic;
    /**
     * 添加逻辑
     * @internal
     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
     */
    addLogic(name?: string): Logic;
    /**
     * 添加逻辑
     * @param logicOptions 逻辑参数
     */
    addLogic(logicOptions: Partial<Logic>): Logic;
    /**
     * 添加逻辑
     * @param logic 已有的逻辑实例
     */
    addLogic(logic: Logic): Logic;
    getOverriddenLogicExistingNames(excludedList?: Array<OverriddenLogic>): string[];
    getOverriddenLogicUniqueName(name?: string): string;
    /**
     * 插入覆写逻辑
     * @internal
     * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
     */
    _insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
    /**
     * 插入覆写逻辑
     * @internal
     * @param overriddenLogicOptions 覆写逻辑参数
     */
    _insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
    /**
     * 插入覆写逻辑
     * @internal
     * @param overriddenLogic 已有的覆写逻辑实例
     */
    _insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
    /**
     * 插入覆写逻辑
     * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
     */
    insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
    /**
     * 插入覆写逻辑
     * @param overriddenLogicOptions 覆写逻辑参数
     */
    insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
    /**
     * 插入覆写逻辑
     * @param overriddenLogic 已有的覆写逻辑实例
     */
    insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @internal
     * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
     */
    _addOverriddenLogic(name?: string): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @internal
     * @param overriddenLogicOptions 覆写逻辑参数
     */
    _addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @internal
     * @param overriddenLogic 已有的覆写逻辑实例
     */
    _addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @internal
     * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
     */
    addOverriddenLogic(name?: string): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @param overriddenLogicOptions 覆写逻辑参数
     */
    addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
    /**
     * 添加覆写逻辑
     * @param overriddenLogic 已有的覆写逻辑实例
     */
    addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
    getInterfaceExistingNames(excludedList?: Array<AbstractInterface>): string[];
    getInterfaceUniqueName(name?: string): string;
    /**
     * 插入接口
     * @internal
     * @param name 接口名称，如果不填会自动生成一个唯一名称
     */
    _insertInterfaceAt(name: string, index: number): types.AbstractInterfaceNode;
    /**
     * 插入接口
     * @internal
     * @param itfaceOptions 接口参数
     */
    _insertInterfaceAt(itfaceOptions: Partial<types.AbstractInterfaceNode>, index: number): types.AbstractInterfaceNode;
    /**
     * 插入接口
     * @internal
     * @param itface 已有的接口实例
     */
    _insertInterfaceAt(itface: types.AbstractInterfaceNode, index: number): types.AbstractInterfaceNode;
    /**
     * 插入接口
     * @param name 接口名称，如果不填会自动生成一个唯一名称
     */
    insertInterfaceAt(name: string, index: number): types.AbstractInterfaceNode;
    /**
     * 插入接口
     * @param itfaceOptions 接口参数
     */
    insertInterfaceAt(itfaceOptions: Partial<types.AbstractInterfaceNode>, index: number): types.AbstractInterfaceNode;
    /**
     * 插入接口
     * @param itface 已有的接口实例
     */
    insertInterfaceAt(itface: types.AbstractInterfaceNode, index: number): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @internal
     * @param name 接口名称，如果不填会自动生成一个唯一名称
     */
    _addInterface(name?: string): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @internal
     * @param itfaceOptions 接口参数
     */
    _addInterface(itfaceOptions: Partial<types.AbstractInterfaceNode>): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @internal
     * @param itface 已有的接口实例
     */
    _addInterface(itface: types.AbstractInterfaceNode): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @internal
     * @param name 接口名称，如果不填会自动生成一个唯一名称
     */
    addInterface(name?: string): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @param itfaceOptions 接口参数
     */
    addInterface(itfaceOptions: Partial<types.AbstractInterfaceNode>): types.AbstractInterfaceNode;
    /**
     * 添加接口
     * @param itface 已有的接口实例
     */
    addInterface(itface: types.AbstractInterfaceNode): types.AbstractInterfaceNode;
    getFrontendTypeExistingNames(excludedList?: Array<FrontendType>): ("pc" | "h5")[];
    getFrontendTypeUniqueName(name?: string): string;
    /**
     * 插入端类型
     * @internal
     * @param name 端类型名称，如果不填会自动生成一个唯一名称
     */
    _insertFrontendTypeAt(name: string, index: number): FrontendType;
    /**
     * 插入端类型
     * @internal
     * @param frontendTypeOptions 端类型参数
     */
    _insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
    /**
     * 插入端类型
     * @internal
     * @param frontendType 已有的端类型实例
     */
    _insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
    /**
     * 插入端类型
     * @param name 端类型名称，如果不填会自动生成一个唯一名称
     */
    insertFrontendTypeAt(name: string, index: number): FrontendType;
    /**
     * 插入端类型
     * @param frontendTypeOptions 端类型参数
     */
    insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
    /**
     * 插入端类型
     * @param frontendType 已有的端类型实例
     */
    insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
    /**
     * 添加端类型
     * @internal
     * @param name 端类型名称，如果不填会自动生成一个唯一名称
     */
    _addFrontendType(name?: string): FrontendType;
    /**
     * 添加端类型
     * @internal
     * @param frontendTypeOptions 端类型参数
     */
    _addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
    /**
     * 添加端类型
     * @internal
     * @param frontendType 已有的端类型实例
     */
    _addFrontendType(frontendType: FrontendType): FrontendType;
    /**
     * 添加端类型
     * @internal
     * @param name 端类型名称，如果不填会自动生成一个唯一名称
     */
    addFrontendType(name?: string): FrontendType;
    /**
     * 添加端类型
     * @param frontendTypeOptions 端类型参数
     */
    addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
    /**
     * 添加端类型
     * @param frontendType 已有的端类型实例
     */
    addFrontendType(frontendType: FrontendType): FrontendType;
    getProcessExistingNames(excludedList?: Array<Process>): string[];
    getProcessUniqueName(name?: string): string;
    /**
     * 插入流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    _insertProcessAt(name: string, index: number): Process;
    /**
     * 插入流程
     * @internal
     * @param processOptions 流程参数
     */
    _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
    /**
     * 插入流程
     * @internal
     * @param process 已有的流程实例
     */
    _insertProcessAt(process: Process, index: number): Process;
    /**
     * 插入流程
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    insertProcessAt(name: string, index: number): Process;
    /**
     * 插入流程
     * @param processOptions 流程参数
     */
    insertProcessAt(processOptions: Partial<Process>, index: number): Process;
    /**
     * 插入流程
     * @param process 已有的流程实例
     */
    insertProcessAt(process: Process, index: number): Process;
    /**
     * 添加流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    _addProcess(name?: string): Process;
    /**
     * 添加流程
     * @internal
     * @param processOptions 流程参数
     */
    _addProcess(processOptions: Partial<Process>): Process;
    /**
     * 添加流程
     * @internal
     * @param process 已有的流程实例
     */
    _addProcess(process: Process): Process;
    /**
     * 添加流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    addProcess(name?: string): Process;
    /**
     * 添加流程
     * @param processOptions 流程参数
     */
    addProcess(processOptions: Partial<Process>): Process;
    /**
     * 添加流程
     * @param process 已有的流程实例
     */
    addProcess(process: Process): Process;
    getProcessV2ExistingNames(excludedList?: Array<ProcessV2>): string[];
    getProcessV2UniqueName(name?: string): string;
    /**
     * 插入流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    _insertProcessV2At(name: string, index: number): ProcessV2;
    /**
     * 插入流程
     * @internal
     * @param processV2Options 流程参数
     */
    _insertProcessV2At(processV2Options: Partial<ProcessV2>, index: number): ProcessV2;
    /**
     * 插入流程
     * @internal
     * @param processV2 已有的流程实例
     */
    _insertProcessV2At(processV2: ProcessV2, index: number): ProcessV2;
    /**
     * 插入流程
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    insertProcessV2At(name: string, index: number): ProcessV2;
    /**
     * 插入流程
     * @param processV2Options 流程参数
     */
    insertProcessV2At(processV2Options: Partial<ProcessV2>, index: number): ProcessV2;
    /**
     * 插入流程
     * @param processV2 已有的流程实例
     */
    insertProcessV2At(processV2: ProcessV2, index: number): ProcessV2;
    /**
     * 添加流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    _addProcessV2(name?: string): ProcessV2;
    /**
     * 添加流程
     * @internal
     * @param processV2Options 流程参数
     */
    _addProcessV2(processV2Options: Partial<ProcessV2>): ProcessV2;
    /**
     * 添加流程
     * @internal
     * @param processV2 已有的流程实例
     */
    _addProcessV2(processV2: ProcessV2): ProcessV2;
    /**
     * 添加流程
     * @internal
     * @param name 流程名称，如果不填会自动生成一个唯一名称
     */
    addProcessV2(name?: string): ProcessV2;
    /**
     * 添加流程
     * @param processV2Options 流程参数
     */
    addProcessV2(processV2Options: Partial<ProcessV2>): ProcessV2;
    /**
     * 添加流程
     * @param processV2 已有的流程实例
     */
    addProcessV2(processV2: ProcessV2): ProcessV2;
    getRoleExistingNames(excludedList?: Array<Role>): string[];
    getRoleUniqueName(name?: string): string;
    /**
     * 插入角色
     * @internal
     * @param name 角色名称，如果不填会自动生成一个唯一名称
     */
    _insertRoleAt(name: string, index: number): Role;
    /**
     * 插入角色
     * @internal
     * @param roleOptions 角色参数
     */
    _insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
    /**
     * 插入角色
     * @internal
     * @param role 已有的角色实例
     */
    _insertRoleAt(role: Role, index: number): Role;
    /**
     * 插入角色
     * @param name 角色名称，如果不填会自动生成一个唯一名称
     */
    insertRoleAt(name: string, index: number): Role;
    /**
     * 插入角色
     * @param roleOptions 角色参数
     */
    insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
    /**
     * 插入角色
     * @param role 已有的角色实例
     */
    insertRoleAt(role: Role, index: number): Role;
    /**
     * 添加角色
     * @internal
     * @param name 角色名称，如果不填会自动生成一个唯一名称
     */
    _addRole(name?: string): Role;
    /**
     * 添加角色
     * @internal
     * @param roleOptions 角色参数
     */
    _addRole(roleOptions: Partial<Role>): Role;
    /**
     * 添加角色
     * @internal
     * @param role 已有的角色实例
     */
    _addRole(role: Role): Role;
    /**
     * 添加角色
     * @internal
     * @param name 角色名称，如果不填会自动生成一个唯一名称
     */
    addRole(name?: string): Role;
    /**
     * 添加角色
     * @param roleOptions 角色参数
     */
    addRole(roleOptions: Partial<Role>): Role;
    /**
     * 添加角色
     * @param role 已有的角色实例
     */
    addRole(role: Role): Role;
    getConnectorExistingNames(excludedList?: Array<Connector>): string[];
    getConnectorUniqueName(name?: string): string;
    /**
     * 插入连接器
     * @internal
     * @param name 连接器名称，如果不填会自动生成一个唯一名称
     */
    _insertConnectorAt(name: string, index: number): Connector;
    /**
     * 插入连接器
     * @internal
     * @param connectorOptions 连接器参数
     */
    _insertConnectorAt(connectorOptions: Partial<Connector>, index: number): Connector;
    /**
     * 插入连接器
     * @internal
     * @param connector 已有的连接器实例
     */
    _insertConnectorAt(connector: Connector, index: number): Connector;
    /**
     * 插入连接器
     * @param name 连接器名称，如果不填会自动生成一个唯一名称
     */
    insertConnectorAt(name: string, index: number): Connector;
    /**
     * 插入连接器
     * @param connectorOptions 连接器参数
     */
    insertConnectorAt(connectorOptions: Partial<Connector>, index: number): Connector;
    /**
     * 插入连接器
     * @param connector 已有的连接器实例
     */
    insertConnectorAt(connector: Connector, index: number): Connector;
    /**
     * 添加连接器
     * @internal
     * @param name 连接器名称，如果不填会自动生成一个唯一名称
     */
    _addConnector(name?: string): Connector;
    /**
     * 添加连接器
     * @internal
     * @param connectorOptions 连接器参数
     */
    _addConnector(connectorOptions: Partial<Connector>): Connector;
    /**
     * 添加连接器
     * @internal
     * @param connector 已有的连接器实例
     */
    _addConnector(connector: Connector): Connector;
    /**
     * 添加连接器
     * @internal
     * @param name 连接器名称，如果不填会自动生成一个唯一名称
     */
    addConnector(name?: string): Connector;
    /**
     * 添加连接器
     * @param connectorOptions 连接器参数
     */
    addConnector(connectorOptions: Partial<Connector>): Connector;
    /**
     * 添加连接器
     * @param connector 已有的连接器实例
     */
    addConnector(connector: Connector): Connector;
    getModuleExistingNames(excludedList?: Array<Module>): string[];
    getModuleUniqueName(name?: string): string;
    /**
     * 插入模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param module 已有的模块实例
     */
    _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
    /**
     * 插入模块
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @param moduleOptions 模块参数
     */
    insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @param module 已有的模块实例
     */
    insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _addModuleInInterfaceDependencies(name?: string): Module;
    /**
     * 添加模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @internal
     * @param module 已有的模块实例
     */
    _addModuleInInterfaceDependencies(module: Module): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    addModuleInInterfaceDependencies(name?: string): Module;
    /**
     * 添加模块
     * @param moduleOptions 模块参数
     */
    addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @param module 已有的模块实例
     */
    addModuleInInterfaceDependencies(module: Module): Module;
    /**
     * 插入模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _insertModuleInSharedAppDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _insertModuleInSharedAppDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param module 已有的模块实例
     */
    _insertModuleInSharedAppDependenciesAt(module: Module, index: number): Module;
    /**
     * 插入模块
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    insertModuleInSharedAppDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @param moduleOptions 模块参数
     */
    insertModuleInSharedAppDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @param module 已有的模块实例
     */
    insertModuleInSharedAppDependenciesAt(module: Module, index: number): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _addModuleInSharedAppDependencies(name?: string): Module;
    /**
     * 添加模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _addModuleInSharedAppDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @internal
     * @param module 已有的模块实例
     */
    _addModuleInSharedAppDependencies(module: Module): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    addModuleInSharedAppDependencies(name?: string): Module;
    /**
     * 添加模块
     * @param moduleOptions 模块参数
     */
    addModuleInSharedAppDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @param module 已有的模块实例
     */
    addModuleInSharedAppDependencies(module: Module): Module;
    /**
     * 插入模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _insertModuleInDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @internal
     * @param module 已有的模块实例
     */
    _insertModuleInDependenciesAt(module: Module, index: number): Module;
    /**
     * 插入模块
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    insertModuleInDependenciesAt(name: string, index: number): Module;
    /**
     * 插入模块
     * @param moduleOptions 模块参数
     */
    insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
    /**
     * 插入模块
     * @param module 已有的模块实例
     */
    insertModuleInDependenciesAt(module: Module, index: number): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    _addModuleInDependencies(name?: string): Module;
    /**
     * 添加模块
     * @internal
     * @param moduleOptions 模块参数
     */
    _addModuleInDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @internal
     * @param module 已有的模块实例
     */
    _addModuleInDependencies(module: Module): Module;
    /**
     * 添加模块
     * @internal
     * @param name 模块名称，如果不填会自动生成一个唯一名称
     */
    addModuleInDependencies(name?: string): Module;
    /**
     * 添加模块
     * @param moduleOptions 模块参数
     */
    addModuleInDependencies(moduleOptions: Partial<Module>): Module;
    /**
     * 添加模块
     * @param module 已有的模块实例
     */
    addModuleInDependencies(module: Module): Module;
    getAuthLogicExistingNames(excludedList?: Array<AuthLogic>): string[];
    getAuthLogicUniqueName(name?: string): string;
    /**
     * 插入鉴权逻辑
     * @internal
     * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    _insertAuthLogicAt(name: string, index: number): AuthLogic;
    /**
     * 插入鉴权逻辑
     * @internal
     * @param authLogicOptions 鉴权逻辑参数
     */
    _insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
    /**
     * 插入鉴权逻辑
     * @internal
     * @param authLogic 已有的鉴权逻辑实例
     */
    _insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
    /**
     * 插入鉴权逻辑
     * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    insertAuthLogicAt(name: string, index: number): AuthLogic;
    /**
     * 插入鉴权逻辑
     * @param authLogicOptions 鉴权逻辑参数
     */
    insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
    /**
     * 插入鉴权逻辑
     * @param authLogic 已有的鉴权逻辑实例
     */
    insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @internal
     * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    _addAuthLogic(name?: string): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @internal
     * @param authLogicOptions 鉴权逻辑参数
     */
    _addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @internal
     * @param authLogic 已有的鉴权逻辑实例
     */
    _addAuthLogic(authLogic: AuthLogic): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @internal
     * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    addAuthLogic(name?: string): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @param authLogicOptions 鉴权逻辑参数
     */
    addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
    /**
     * 添加鉴权逻辑
     * @param authLogic 已有的鉴权逻辑实例
     */
    addAuthLogic(authLogic: AuthLogic): AuthLogic;
    getAuthLogicForCallInterfaceExistingNames(excludedList?: Array<AuthLogicForCallInterface>): string[];
    getAuthLogicForCallInterfaceUniqueName(name?: string): string;
    /**
     * 插入调用接口的鉴权逻辑
     * @internal
     * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
    /**
     * 插入调用接口的鉴权逻辑
     * @internal
     * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
     */
    _insertAuthLogicForCallInterfaceAt(authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>, index: number): AuthLogicForCallInterface;
    /**
     * 插入调用接口的鉴权逻辑
     * @internal
     * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
     */
    _insertAuthLogicForCallInterfaceAt(authLogicForCallInterface: AuthLogicForCallInterface, index: number): AuthLogicForCallInterface;
    /**
     * 插入调用接口的鉴权逻辑
     * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
    /**
     * 插入调用接口的鉴权逻辑
     * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
     */
    insertAuthLogicForCallInterfaceAt(authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>, index: number): AuthLogicForCallInterface;
    /**
     * 插入调用接口的鉴权逻辑
     * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
     */
    insertAuthLogicForCallInterfaceAt(authLogicForCallInterface: AuthLogicForCallInterface, index: number): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @internal
     * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @internal
     * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
     */
    _addAuthLogicForCallInterface(authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @internal
     * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
     */
    _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @internal
     * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
     */
    addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
     */
    addAuthLogicForCallInterface(authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>): AuthLogicForCallInterface;
    /**
     * 添加调用接口的鉴权逻辑
     * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
     */
    addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
    getConnectionExistingNames(excludedList?: Array<Connection>): string[];
    getConnectionUniqueName(name?: string): string;
    /**
     * 插入连接
     * @internal
     * @param name 连接名称，如果不填会自动生成一个唯一名称
     */
    _insertConnectionAt(name: string, index: number): Connection;
    /**
     * 插入连接
     * @internal
     * @param connectionOptions 连接参数
     */
    _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
    /**
     * 插入连接
     * @internal
     * @param connection 已有的连接实例
     */
    _insertConnectionAt(connection: Connection, index: number): Connection;
    /**
     * 插入连接
     * @param name 连接名称，如果不填会自动生成一个唯一名称
     */
    insertConnectionAt(name: string, index: number): Connection;
    /**
     * 插入连接
     * @param connectionOptions 连接参数
     */
    insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
    /**
     * 插入连接
     * @param connection 已有的连接实例
     */
    insertConnectionAt(connection: Connection, index: number): Connection;
    /**
     * 添加连接
     * @internal
     * @param name 连接名称，如果不填会自动生成一个唯一名称
     */
    _addConnection(name?: string): Connection;
    /**
     * 添加连接
     * @internal
     * @param connectionOptions 连接参数
     */
    _addConnection(connectionOptions: Partial<Connection>): Connection;
    /**
     * 添加连接
     * @internal
     * @param connection 已有的连接实例
     */
    _addConnection(connection: Connection): Connection;
    /**
     * 添加连接
     * @internal
     * @param name 连接名称，如果不填会自动生成一个唯一名称
     */
    addConnection(name?: string): Connection;
    /**
     * 添加连接
     * @param connectionOptions 连接参数
     */
    addConnection(connectionOptions: Partial<Connection>): Connection;
    /**
     * 添加连接
     * @param connection 已有的连接实例
     */
    addConnection(connection: Connection): Connection;
    getTriggerLauncherExistingNames(excludedList?: Array<TriggerLauncher>): string[];
    getTriggerLauncherUniqueName(name?: string): string;
    /**
     * 插入触发器启动器
     * @internal
     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
     */
    _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
    /**
     * 插入触发器启动器
     * @internal
     * @param triggerLauncherOptions 触发器启动器参数
     */
    _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
    /**
     * 插入触发器启动器
     * @internal
     * @param triggerLauncher 已有的触发器启动器实例
     */
    _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
    /**
     * 插入触发器启动器
     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
     */
    insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
    /**
     * 插入触发器启动器
     * @param triggerLauncherOptions 触发器启动器参数
     */
    insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
    /**
     * 插入触发器启动器
     * @param triggerLauncher 已有的触发器启动器实例
     */
    insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @internal
     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
     */
    _addTriggerLauncher(name?: string): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @internal
     * @param triggerLauncherOptions 触发器启动器参数
     */
    _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @internal
     * @param triggerLauncher 已有的触发器启动器实例
     */
    _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @internal
     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
     */
    addTriggerLauncher(name?: string): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @param triggerLauncherOptions 触发器启动器参数
     */
    addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
    /**
     * 添加触发器启动器
     * @param triggerLauncher 已有的触发器启动器实例
     */
    addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
    getMetadataTypeExistingNames(excludedList?: Array<MetadataType>): string[];
    getMetadataTypeUniqueName(name?: string): string;
    /**
     * 插入元数据类型
     * @internal
     * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
     */
    _insertMetadataTypeAt(name: string, index: number): MetadataType;
    /**
     * 插入元数据类型
     * @internal
     * @param metadataTypeOptions 元数据类型参数
     */
    _insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
    /**
     * 插入元数据类型
     * @internal
     * @param metadataType 已有的元数据类型实例
     */
    _insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
    /**
     * 插入元数据类型
     * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
     */
    insertMetadataTypeAt(name: string, index: number): MetadataType;
    /**
     * 插入元数据类型
     * @param metadataTypeOptions 元数据类型参数
     */
    insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
    /**
     * 插入元数据类型
     * @param metadataType 已有的元数据类型实例
     */
    insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
    /**
     * 添加元数据类型
     * @internal
     * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
     */
    _addMetadataType(name?: string): MetadataType;
    /**
     * 添加元数据类型
     * @internal
     * @param metadataTypeOptions 元数据类型参数
     */
    _addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
    /**
     * 添加元数据类型
     * @internal
     * @param metadataType 已有的元数据类型实例
     */
    _addMetadataType(metadataType: MetadataType): MetadataType;
    /**
     * 添加元数据类型
     * @internal
     * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
     */
    addMetadataType(name?: string): MetadataType;
    /**
     * 添加元数据类型
     * @param metadataTypeOptions 元数据类型参数
     */
    addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
    /**
     * 添加元数据类型
     * @param metadataType 已有的元数据类型实例
     */
    addMetadataType(metadataType: MetadataType): MetadataType;
    getDirectoryExistingNames(excludedList?: Array<Directory>): string[];
    getDirectoryUniqueName(name?: string): string;
    /**
     * 插入文件夹
     * @internal
     * @param name 文件夹名称，如果不填会自动生成一个唯一名称
     */
    _insertDirectoryAt(name: string, index: number): Directory;
    /**
     * 插入文件夹
     * @internal
     * @param directoryOptions 文件夹参数
     */
    _insertDirectoryAt(directoryOptions: Partial<Directory>, index: number): Directory;
    /**
     * 插入文件夹
     * @internal
     * @param directory 已有的文件夹实例
     */
    _insertDirectoryAt(directory: Directory, index: number): Directory;
    /**
     * 插入文件夹
     * @param name 文件夹名称，如果不填会自动生成一个唯一名称
     */
    insertDirectoryAt(name: string, index: number): Directory;
    /**
     * 插入文件夹
     * @param directoryOptions 文件夹参数
     */
    insertDirectoryAt(directoryOptions: Partial<Directory>, index: number): Directory;
    /**
     * 插入文件夹
     * @param directory 已有的文件夹实例
     */
    insertDirectoryAt(directory: Directory, index: number): Directory;
    /**
     * 添加文件夹
     * @internal
     * @param name 文件夹名称，如果不填会自动生成一个唯一名称
     */
    _addDirectory(name?: string): Directory;
    /**
     * 添加文件夹
     * @internal
     * @param directoryOptions 文件夹参数
     */
    _addDirectory(directoryOptions: Partial<Directory>): Directory;
    /**
     * 添加文件夹
     * @internal
     * @param directory 已有的文件夹实例
     */
    _addDirectory(directory: Directory): Directory;
    /**
     * 添加文件夹
     * @internal
     * @param name 文件夹名称，如果不填会自动生成一个唯一名称
     */
    addDirectory(name?: string): Directory;
    /**
     * 添加文件夹
     * @param directoryOptions 文件夹参数
     */
    addDirectory(directoryOptions: Partial<Directory>): Directory;
    /**
     * 添加文件夹
     * @param directory 已有的文件夹实例
     */
    addDirectory(directory: Directory): Directory;
    /**
     * 删除数据源
     * @param name 数据源名称
     */
    removeDataSource(name: string): void;
    /**
     * 删除数据源
     * @param dataSource 已有的数据源实例
     */
    removeDataSource(dataSource: DataSource): void;
    /**
     * 删除数据结构
     * @param name 数据结构名称
     */
    removeStructure(name: string): void;
    /**
     * 删除数据结构
     * @param structure 已有的数据结构实例
     */
    removeStructure(structure: Structure): void;
    /**
     * 删除枚举
     * @param name 枚举名称
     */
    removeEnum(name: string): void;
    /**
     * 删除枚举
     * @param enumeration 已有的枚举实例
     */
    removeEnum(enumeration: Enum): void;
    /**
     * 删除逻辑
     * @param name 逻辑名称
     */
    removeLogic(name: string): void;
    /**
     * 删除逻辑
     * @param logic 已有的逻辑实例
     */
    removeLogic(logic: Logic): void;
    /**
     * 删除覆写逻辑
     * @param name 覆写逻辑名称
     */
    removeOverriddenLogic(name: string): void;
    /**
     * 删除覆写逻辑
     * @param overriddenLogic 已有的覆写逻辑实例
     */
    removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
    /**
     * 删除接口
     * @param name 接口名称
     */
    removeInterface(name: string): void;
    /**
     * 删除接口
     * @param itface 已有的接口实例
     */
    removeInterface(itface: types.AbstractInterfaceNode): void;
    /**
     * 删除端类型
     * @param name 端类型名称
     */
    removeFrontendType(name: string): void;
    /**
     * 删除端类型
     * @param frontendType 已有的端类型实例
     */
    removeFrontendType(frontendType: FrontendType): void;
    /**
     * 删除流程
     * @param name 流程名称
     */
    removeProcess(name: string): void;
    /**
     * 删除流程
     * @param process 已有的流程实例
     */
    removeProcess(process: Process): void;
    /**
     * 删除流程
     * @param name 流程名称
     */
    removeProcessV2(name: string): void;
    /**
     * 删除流程
     * @param processV2 已有的流程实例
     */
    removeProcessV2(processV2: ProcessV2): void;
    /**
     * 删除角色
     * @param name 角色名称
     */
    removeRole(name: string): void;
    /**
     * 删除角色
     * @param role 已有的角色实例
     */
    removeRole(role: Role): void;
    /**
     * 删除连接器
     * @param name 连接器名称
     */
    removeConnector(name: string): void;
    /**
     * 删除连接器
     * @param connector 已有的连接器实例
     */
    removeConnector(connector: Connector): void;
    /**
     * 删除模块
     * @param name 模块名称
     */
    removeModuleInInterfaceDependencies(name: string): void;
    /**
     * 删除模块
     * @param module 已有的模块实例
     */
    removeModuleInInterfaceDependencies(module: Module): void;
    /**
     * 删除模块
     * @param name 模块名称
     */
    removeModuleInSharedAppDependencies(name: string): void;
    /**
     * 删除模块
     * @param module 已有的模块实例
     */
    removeModuleInSharedAppDependencies(module: Module): void;
    /**
     * 删除模块
     * @param name 模块名称
     */
    removeModuleInDependencies(name: string): void;
    /**
     * 删除模块
     * @param module 已有的模块实例
     */
    removeModuleInDependencies(module: Module): void;
    /**
     * 删除鉴权逻辑
     * @param name 鉴权逻辑名称
     */
    removeAuthLogic(name: string): void;
    /**
     * 删除鉴权逻辑
     * @param authLogic 已有的鉴权逻辑实例
     */
    removeAuthLogic(authLogic: AuthLogic): void;
    /**
     * 删除调用接口的鉴权逻辑
     * @param name 调用接口的鉴权逻辑名称
     */
    removeAuthLogicForCallInterface(name: string): void;
    /**
     * 删除调用接口的鉴权逻辑
     * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
     */
    removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
    /**
     * 删除连接
     * @param name 连接名称
     */
    removeConnection(name: string): void;
    /**
     * 删除连接
     * @param connection 已有的连接实例
     */
    removeConnection(connection: Connection): void;
    /**
     * 删除触发器启动器
     * @param name 触发器启动器名称
     */
    removeTriggerLauncher(name: string): void;
    /**
     * 删除触发器启动器
     * @param triggerLauncher 已有的触发器启动器实例
     */
    removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
    /**
     * 删除元数据类型
     * @param name 元数据类型名称
     */
    removeMetadataType(name: string): void;
    /**
     * 删除元数据类型
     * @param metadataType 已有的元数据类型实例
     */
    removeMetadataType(metadataType: MetadataType): void;
    /**
     * 删除文件夹
     * @param name 文件夹名称
     */
    removeDirectory(name: string): void;
    /**
     * 删除文件夹
     * @param directory 已有的文件夹实例
     */
    removeDirectory(directory: Directory): void;
    getDefaultOnAnno(): any;
    findDataSourceByName(name: string): DataSource;
    get defaultDS(): DataSource;
    findEnumByName(name: string): Enum;
    findStructureByName(name: string): Structure;
    findLogicByName(name: string): Logic;
    /**
     * 是否为官方应用
     */
    officialType: 'official' | 'nonofficial';
    /**
     * 轻舟项目 Id
     */
    projectId: string;
    /**
     * 租户 Id
     */
    tenantId: string;
    /**
     * 租户 Id
     */
    userGroupId: string;
    /**
     * 多环境
     */
    envs: string;
    /**
     * 多环境
     */
    envList: Array<string>;
    /**
     * 发布状态
     */
    deploying: boolean;
    /**
     * 发布 Id
     */
    deploymentId: number;
    /**
     * 从模板创建的模板 Id
     */
    templateId: number;
    /**
     * 组合节点缓存
     */
    composeCache: composeCacheType;
    /**
     * 语言服务
     */
    naslServer: NaslServer.Server;
    /**
     * 是否启动新版流程
     */
    newProcessVersion: boolean;
    /**
     * 是否启动表单设计器
     */
    formDesignerEnabled: boolean;
    /**
  
    /**
     * 判断缓存是否为空
     */
    isComposeCacheEmpty(): boolean;
    /**
     * 获取组合节点
     */
    getCompose(path: string[]): composeCacheType;
    /**
     * 获取组合节点
     */
    getComposeNodes(path: string[]): any[];
    /**
     * 获取表单/表格设计器节点的路径列表
     */
    getComposeNodePaths(): any[];
    /**
     * 往组合内添加节点
     */
    addComposeNodes(path: string[], node: BaseNode | BaseNode[]): void;
    /**
     * 删除分组, 包括子集
     */
    deleteCompose(path: string[]): void;
    /**
     * 释放分组内所有节点， 包括子分组
     */
    releaseComposeNode(path: string[]): void;
    /**
     * 删除分组内的某一个
     */
    deleteComposeNode(path: string[], node: BaseNode): void;
    /**
     * 根据条件清除分组内的节点
     */
    clearComposeNodesByCondition(path: string[], condition: (nodes: BaseNode[]) => BaseNode[]): void;
    /**
     * 清空某一分组
     */
    clearComposeNodes(path: string[]): void;
    /**
     * 获取页面元素节点下的同一composedBy分组的节点
     */
    getViewElementEmbeddedNodes(node: BaseNode): BaseNode[];
    /**
     * 获取命名空间
     */
    getNamespace(): string;
    getTsNamespace(): string;
    findNodeByPath(nodePath: string): SyntaxNode | undefined;
    findNodeByCompleteName(originCompleteName: string): any;
    loadEnvList(): void;
    packageInfos: Array<{
        template: {
            name: string;
            version: string;
            frameworkKind: string;
        }[];
        ui: {
            name: string;
            version: string;
            frameworkKind: string;
            libName: string;
        }[];
        scope: string;
    }>;
    loadPackageInfos(inputMaterialConfig?: any): {
        template: {
            name: string;
            version: string;
            frameworkKind: string;
        }[];
        ui: {
            name: string;
            version: string;
            frameworkKind: string;
            libName: string;
        }[];
        scope: string;
    }[];
    /**
     * 根据 packageInfo 的信息生成用于 load 的 assetsInfo
     * 在环境中需要 basic 和 custom 分开 load，否则容易报错
     * @param prefix
     */
    genAllAssetsInfo(prefix: string, scope: string, frameworkKind: string): {
        basic: AssetsInfo;
        custom?: AssetsInfo;
        libs?: Array<LibInfo>;
    };
    onChange($event?: EventPayload): void;
    addModuleInDependenciesWithDataSource(options?: string | Partial<Module> | Module): void;
    statistics(): {
        entityCount: number;
        structureCount: number;
        enumCount: number;
        logicCount: number;
        viewCount: number;
        processCount: number;
    };
    /**
     * 需要包含依赖库里的dataSources，不自动生成
     */
    getDataSourceExistingNames(excludedList?: Array<DataSource>): string[];
    /**
     * 更新系统权限表名
     */
    updatePermissionTableName(oldPrefix: string | null | undefined, newPrefix: string | null | undefined): void;
    /**
     * 更新全局设置 preferenceMap
     */
    updatePreferenceMap(preferences?: Record<string, string>): void;
    getQualifiedInterface(interfaces?: AbstractInterface[]): MessageData[];
    getFrontendExistingTitles(excludedList?: Array<Frontend>): string[];
    getExtensionsCallbackLogics(): string[];
    getJavaLogicUniqueName(name?: string): string;
    getJavaLogicClassUniqueName(name?: string): string;
    genAllCustomComponents(): {
        pc: Array<any>;
        h5: Array<any>;
    };
    /**
     * 当前正在发布的环境，临时状态
     */
    curDeployEnv: string;
    /**
     * 获取 “系统统一路径前缀”
     * @returns
     */
    get sysPrefixPath(): string;
    __databaseTypeMap: any;
    getAuthInterfaceUniqueName(name?: string): void;
    get appTimeZone(): string;
    /** 根据名称获取 triggerLauncher */
    getTriggerLauncherByName(name: string): TriggerLauncher;
    /** 根据名称获取 Logic */
    getLogicByName(name: string): Logic;
    /** 获取已经存在的Module title */
    getConnectorExistingTitles(excludedList?: Array<Module>): string[];
    /** hank */
    toNaturalTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
    toTextualNASL(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
    _callLogicUuidToHeaderMap?: Record<string, string>;
    saveCallLogicUuidToHeaderMap(callLogicUuidToHeaderMap: Record<string, string>): void;
    getCallLogicHeader(callLogicUuid: string): string;
    _databaseConfigIdToTypeMap?: Record<string, string>;
    saveDatabaseConfigIdToTypeMap(databaseConfigIdToTypeMap: Record<string, string>): void;
    get allDataSources(): DataSource[];
    getSameSourceDataSources(dsCompleteName: string): string[];
    getEnvLabel(envName: string): any;
    /**
     * 创建静默 App 实例
     *
     * @description 该模式下将会屏蔽所有节点事件，并且原则上不允许修改节点数据
     */
    static createSilenceApp(data: object): App;
}
export default App;
//# sourceMappingURL=App__.d.ts.map