type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
import { TranslatorGenerator } from '@lcap/nasl-translator';
import type { AuthInterface } from './AuthInterface__';
import type Interface from './Interface__';
import type { Embedded } from '@lcap/nasl-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 AbstractInterface from './AbstractInterface__';
import type View from './View__';
import type Variable from './Variable__';
import type Process from './Process__';
import type ProcessV2 from './ProcessV2__';
import type FrontendLibrary from './FrontendLibrary__';
import type Configuration from './Configuration__';
import type TriggerLauncher from './TriggerLauncher__';
import type Connection from './Connection__';
import type MetadataType from './MetadataType__';
import type Annotation from './Annotation__';
import type Directory from './Directory__';
/**
 * 模块
 */
export declare class Module extends BaseNode {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'Module' | 'Connector';
    /**
     * type
     */
    type: 'extension' | 'interface' | 'component' | 'connector' | 'customInterface' | 'sharedApp';
    /**
     * version
     */
    version: string;
    /**
     * 模块名称
     */
    name: string;
    /**
     * 模块标题
     */
    title?: string;
    /**
     * 模块描述
     */
    description?: string;
    /**
     * provider
     */
    provider?: string;
    /**
     * 外部语言依赖
     */
    externalDependencyMap?: {
        maven?: Array<{
            groupId: string;
            artifactId: string;
            version: string;
        }>;
        npm?: Array<{
            name: string;
            version: string;
        }>;
        jdk?: {
            version: string;
        };
    };
    /**
     * 外部语言依赖
     */
    compilerInfoMap?: {
        java?: Array<{
            packageName: string;
            className: string;
            naslName: string;
            type: string;
            javaTypes: Record<string, string>;
        }>;
        js?: {
            prefix: string;
        };
    } | Record<string, string>;
    /**
     * 数据源列表
     */
    dataSources: Array<DataSource>;
    /**
     * 数据结构列表
     */
    structures: Array<Structure>;
    /**
     * 枚举列表
     */
    enums: Array<Enum>;
    /**
     * 逻辑列表
     */
    logics: Array<Logic>;
    /**
     * 接口列表
     */
    interfaces: Array<types.AbstractInterfaceNode>;
    /**
     * 页面列表
     */
    views: Array<View>;
    /**
     * 变量列表
     */
    frontendVariables: Array<Variable>;
    /**
     * 流程列表
     */
    processes: Array<Process>;
    /**
     * 流程列表
     */
    processV2s: Array<ProcessV2>;
    /**
     * 前端库列表
     */
    frontends: Array<FrontendLibrary>;
    /**
     * 配置管理
     */
    configuration?: Configuration;
    /**
     * 触发器启动器列表
     */
    triggerLaunchers: Array<TriggerLauncher>;
    /**
     * 连接列表
     */
    connections?: Array<Connection>;
    /**
     * 元数据类型列表
     */
    metadataTypes: Array<MetadataType>;
    /**
     * 注解列表
     */
    annotations: Array<Annotation>;
    /**
     * 文件夹列表
     */
    directories: Array<Directory>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<Module>);
    static from(source: any, parentNode?: any, parentKey?: string): Module;
    /**
     * 设置模块名称
     */
    setName(name: string): void;
    /**
     * 设置模块标题
     */
    setTitle(title: string): void;
    /**
     * 设置模块描述
     */
    setDescription(description: string): void;
    getDataSourceExistingNames(excludedList?: Array<DataSource>): string[];
    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;
    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;
    getViewExistingNames(excludedList?: Array<View>): string[];
    getViewUniqueName(name?: string): string;
    /**
     * 插入页面
     * @internal
     * @param name 页面名称，如果不填会自动生成一个唯一名称
     */
    _insertViewAt(name: string, index: number): View;
    /**
     * 插入页面
     * @internal
     * @param viewOptions 页面参数
     */
    _insertViewAt(viewOptions: Partial<View>, index: number): View;
    /**
     * 插入页面
     * @internal
     * @param view 已有的页面实例
     */
    _insertViewAt(view: View, index: number): View;
    /**
     * 插入页面
     * @param name 页面名称，如果不填会自动生成一个唯一名称
     */
    insertViewAt(name: string, index: number): View;
    /**
     * 插入页面
     * @param viewOptions 页面参数
     */
    insertViewAt(viewOptions: Partial<View>, index: number): View;
    /**
     * 插入页面
     * @param view 已有的页面实例
     */
    insertViewAt(view: View, index: number): View;
    /**
     * 添加页面
     * @internal
     * @param name 页面名称，如果不填会自动生成一个唯一名称
     */
    _addView(name?: string): View;
    /**
     * 添加页面
     * @internal
     * @param viewOptions 页面参数
     */
    _addView(viewOptions: Partial<View>): View;
    /**
     * 添加页面
     * @internal
     * @param view 已有的页面实例
     */
    _addView(view: View): View;
    /**
     * 添加页面
     * @internal
     * @param name 页面名称，如果不填会自动生成一个唯一名称
     */
    addView(name?: string): View;
    /**
     * 添加页面
     * @param viewOptions 页面参数
     */
    addView(viewOptions: Partial<View>): View;
    /**
     * 添加页面
     * @param view 已有的页面实例
     */
    addView(view: View): View;
    getVarExistingNames(excludedList?: Array<Variable>): string[];
    getVariableUniqueName(name?: string): string;
    /**
     * 插入变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    _insertVariableAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variableOptions 变量参数
     */
    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variable 已有的变量实例
     */
    _insertVariableAt(variable: Variable, index: number): Variable;
    /**
     * 插入变量
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    insertVariableAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @param variableOptions 变量参数
     */
    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @param variable 已有的变量实例
     */
    insertVariableAt(variable: Variable, index: number): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    _addVariable(name?: string): Variable;
    /**
     * 添加变量
     * @internal
     * @param variableOptions 变量参数
     */
    _addVariable(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @internal
     * @param variable 已有的变量实例
     */
    _addVariable(variable: Variable): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    addVariable(name?: string): Variable;
    /**
     * 添加变量
     * @param variableOptions 变量参数
     */
    addVariable(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @param variable 已有的变量实例
     */
    addVariable(variable: Variable): Variable;
    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;
    getFrontendLibraryExistingNames(excludedList?: Array<FrontendLibrary>): ("pc" | "h5")[];
    getFrontendLibraryUniqueName(name?: string): string;
    /**
     * 插入前端库
     * @internal
     * @param name 前端库名称，如果不填会自动生成一个唯一名称
     */
    _insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
    /**
     * 插入前端库
     * @internal
     * @param frontendLibraryOptions 前端库参数
     */
    _insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
    /**
     * 插入前端库
     * @internal
     * @param frontendLibrary 已有的前端库实例
     */
    _insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
    /**
     * 插入前端库
     * @param name 前端库名称，如果不填会自动生成一个唯一名称
     */
    insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
    /**
     * 插入前端库
     * @param frontendLibraryOptions 前端库参数
     */
    insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
    /**
     * 插入前端库
     * @param frontendLibrary 已有的前端库实例
     */
    insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
    /**
     * 添加前端库
     * @internal
     * @param name 前端库名称，如果不填会自动生成一个唯一名称
     */
    _addFrontendLibrary(name?: string): FrontendLibrary;
    /**
     * 添加前端库
     * @internal
     * @param frontendLibraryOptions 前端库参数
     */
    _addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
    /**
     * 添加前端库
     * @internal
     * @param frontendLibrary 已有的前端库实例
     */
    _addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
    /**
     * 添加前端库
     * @internal
     * @param name 前端库名称，如果不填会自动生成一个唯一名称
     */
    addFrontendLibrary(name?: string): FrontendLibrary;
    /**
     * 添加前端库
     * @param frontendLibraryOptions 前端库参数
     */
    addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
    /**
     * 添加前端库
     * @param frontendLibrary 已有的前端库实例
     */
    addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
    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;
    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;
    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;
    getAnnotationExistingNames(excludedList?: Array<Annotation>): string[];
    getAnnotationUniqueName(name?: string): string;
    /**
     * 插入注解
     * @internal
     * @param name 注解名称，如果不填会自动生成一个唯一名称
     */
    _insertAnnotationAt(name: string, index: number): Annotation;
    /**
     * 插入注解
     * @internal
     * @param annotationOptions 注解参数
     */
    _insertAnnotationAt(annotationOptions: Partial<Annotation>, index: number): Annotation;
    /**
     * 插入注解
     * @internal
     * @param annotation 已有的注解实例
     */
    _insertAnnotationAt(annotation: Annotation, index: number): Annotation;
    /**
     * 插入注解
     * @param name 注解名称，如果不填会自动生成一个唯一名称
     */
    insertAnnotationAt(name: string, index: number): Annotation;
    /**
     * 插入注解
     * @param annotationOptions 注解参数
     */
    insertAnnotationAt(annotationOptions: Partial<Annotation>, index: number): Annotation;
    /**
     * 插入注解
     * @param annotation 已有的注解实例
     */
    insertAnnotationAt(annotation: Annotation, index: number): Annotation;
    /**
     * 添加注解
     * @internal
     * @param name 注解名称，如果不填会自动生成一个唯一名称
     */
    _addAnnotation(name?: string): Annotation;
    /**
     * 添加注解
     * @internal
     * @param annotationOptions 注解参数
     */
    _addAnnotation(annotationOptions: Partial<Annotation>): Annotation;
    /**
     * 添加注解
     * @internal
     * @param annotation 已有的注解实例
     */
    _addAnnotation(annotation: Annotation): Annotation;
    /**
     * 添加注解
     * @internal
     * @param name 注解名称，如果不填会自动生成一个唯一名称
     */
    addAnnotation(name?: string): Annotation;
    /**
     * 添加注解
     * @param annotationOptions 注解参数
     */
    addAnnotation(annotationOptions: Partial<Annotation>): Annotation;
    /**
     * 添加注解
     * @param annotation 已有的注解实例
     */
    addAnnotation(annotation: Annotation): Annotation;
    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 接口名称
     */
    removeInterface(name: string): void;
    /**
     * 删除接口
     * @param itface 已有的接口实例
     */
    removeInterface(itface: types.AbstractInterfaceNode): void;
    /**
     * 删除页面
     * @param name 页面名称
     */
    removeView(name: string): void;
    /**
     * 删除页面
     * @param view 已有的页面实例
     */
    removeView(view: View): void;
    /**
     * 删除变量
     * @param name 变量名称
     */
    removeVariable(name: string): void;
    /**
     * 删除变量
     * @param variable 已有的变量实例
     */
    removeVariable(variable: Variable): 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 前端库名称
     */
    removeFrontendLibrary(name: string): void;
    /**
     * 删除前端库
     * @param frontendLibrary 已有的前端库实例
     */
    removeFrontendLibrary(frontendLibrary: FrontendLibrary): void;
    /**
     * 删除触发器启动器
     * @param name 触发器启动器名称
     */
    removeTriggerLauncher(name: string): void;
    /**
     * 删除触发器启动器
     * @param triggerLauncher 已有的触发器启动器实例
     */
    removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
    /**
     * 删除连接
     * @param name 连接名称
     */
    removeConnection(name: string): void;
    /**
     * 删除连接
     * @param connection 已有的连接实例
     */
    removeConnection(connection: Connection): void;
    /**
     * 删除元数据类型
     * @param name 元数据类型名称
     */
    removeMetadataType(name: string): void;
    /**
     * 删除元数据类型
     * @param metadataType 已有的元数据类型实例
     */
    removeMetadataType(metadataType: MetadataType): void;
    /**
     * 删除注解
     * @param name 注解名称
     */
    removeAnnotation(name: string): void;
    /**
     * 删除注解
     * @param annotation 已有的注解实例
     */
    removeAnnotation(annotation: Annotation): void;
    /**
     * 删除文件夹
     * @param name 文件夹名称
     */
    removeDirectory(name: string): void;
    /**
     * 删除文件夹
     * @param directory 已有的文件夹实例
     */
    removeDirectory(directory: Directory): void;
    /**
     * 用于区分存量应用新导入模块,存量应用替换数据结构使用
     */
    isAdd: boolean;
    enable: boolean;
    setIsAdd(isAdd: boolean): void;
    /**
     * 生成宿主语言的文件路径
     * @param name 一般不用传，用于 rename
     */
    getEmbeddedFilePath(name?: string): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    toEmbeddedTSFile(): Embedded.TSFileGenerator<Module>;
    /**
     * 获取命名空间和
     * 暂时不考虑 Module 嵌套的情况
     */
    getNamespace(): string;
    getTsNamespace(): string;
    getTsNamespaceAndName(): string;
    findEnumByName(name: string): Enum;
    getFEManifest(): any;
    checkFileInManifest(fileName: string): boolean;
    /**
     *  获取属性节点是否存在
     */
    findProperty(name: string, propertyType: PropertyType): any;
    delete(): void;
    softDelete(options: {
        index: number;
    }): void;
    setInterfaces(interfaces: Array<Interface | AuthInterface>): void;
    getInterfaceStructureMap(): Map<Structure, Set<Interface>>;
    /**
     * 设置版本号
     */
    setVersion(version: string): void;
    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;
    coverConfiguration(configuration: Configuration): void;
    get isSharedApp(): boolean;
}
export default Module;
//# sourceMappingURL=Module__.d.ts.map