import { TranslatorGenerator } from '@lcap/nasl-translator';
import { Embedded } from '@lcap/nasl-types';
import * as types from './utils/types';
import BaseNode from '../common/BaseNode';
import type Process from './Process__';
import type ProcessV2 from './ProcessV2__';
import type Structure from './Structure__';
import type Enum from './Enum__';
import type Logic from './Logic__';
import type Function from './Function__';
import type AbstractInterface from './AbstractInterface__';
import type View from './View__';
import type Variable from './Variable__';
import type ViewComponentDeclaration from './ViewComponentDeclaration__';
import type ProcessComponent from './ProcessComponent__';
/**
 * 命名空间
 */
export declare class Namespace extends BaseNode {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'Namespace';
    /**
     * 表示是从实体还是流程等概念产生的
     */
    originConcept?: string;
    /**
     * 命名空间名称
     */
    name: string;
    /**
     * 命名空间标题
     */
    title: string;
    /**
     * 命名空间描述
     */
    description?: string;
    /**
     * 命名空间列表
     */
    children: Array<Namespace>;
    /**
     * 流程列表
     */
    processes: Array<Process>;
    /**
     * 流程列表
     */
    processV2s: Array<ProcessV2>;
    /**
     * 数据结构列表
     */
    structures: Array<Structure>;
    /**
     * 枚举列表
     */
    enums: Array<Enum>;
    /**
     * 逻辑列表
     */
    logics: Array<Logic>;
    /**
     * 函数列表
     */
    functions: Array<Function>;
    /**
     * 接口列表
     */
    interfaces: Array<types.AbstractInterfaceNode>;
    /**
     * 页面列表
     */
    views: Array<View>;
    /**
     * 变量列表
     */
    frontendVariables: Array<Variable>;
    /**
     * 变量列表
     */
    variables: Array<Variable>;
    /**
     * 页面组件列表
     */
    viewComponents: Array<ViewComponentDeclaration>;
    /**
     * 流程组件列表
     */
    processComponents: Array<ProcessComponent>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<Namespace>);
    static from(source: any, parentNode?: any, parentKey?: string): Namespace;
    getNamespaceExistingNames(excludedList?: Array<Namespace>): string[];
    getNamespaceUniqueName(name?: string): string;
    /**
     * 插入命名空间
     * @internal
     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
     */
    _insertNamespaceAt(name: string, index: number): Namespace;
    /**
     * 插入命名空间
     * @internal
     * @param namespaceOptions 命名空间参数
     */
    _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
    /**
     * 插入命名空间
     * @internal
     * @param namespace 已有的命名空间实例
     */
    _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
    /**
     * 插入命名空间
     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
     */
    insertNamespaceAt(name: string, index: number): Namespace;
    /**
     * 插入命名空间
     * @param namespaceOptions 命名空间参数
     */
    insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
    /**
     * 插入命名空间
     * @param namespace 已有的命名空间实例
     */
    insertNamespaceAt(namespace: Namespace, index: number): Namespace;
    /**
     * 添加命名空间
     * @internal
     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
     */
    _addNamespace(name?: string): Namespace;
    /**
     * 添加命名空间
     * @internal
     * @param namespaceOptions 命名空间参数
     */
    _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
    /**
     * 添加命名空间
     * @internal
     * @param namespace 已有的命名空间实例
     */
    _addNamespace(namespace: Namespace): Namespace;
    /**
     * 添加命名空间
     * @internal
     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
     */
    addNamespace(name?: string): Namespace;
    /**
     * 添加命名空间
     * @param namespaceOptions 命名空间参数
     */
    addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
    /**
     * 添加命名空间
     * @param namespace 已有的命名空间实例
     */
    addNamespace(namespace: Namespace): Namespace;
    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;
    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;
    getFunctionExistingNames(excludedList?: Array<Function>): string[];
    getFunctionUniqueName(name?: string): string;
    /**
     * 插入函数
     * @internal
     * @param name 函数名称，如果不填会自动生成一个唯一名称
     */
    _insertFunctionAt(name: string, index: number): Function;
    /**
     * 插入函数
     * @internal
     * @param funcOptions 函数参数
     */
    _insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
    /**
     * 插入函数
     * @internal
     * @param func 已有的函数实例
     */
    _insertFunctionAt(func: Function, index: number): Function;
    /**
     * 插入函数
     * @param name 函数名称，如果不填会自动生成一个唯一名称
     */
    insertFunctionAt(name: string, index: number): Function;
    /**
     * 插入函数
     * @param funcOptions 函数参数
     */
    insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
    /**
     * 插入函数
     * @param func 已有的函数实例
     */
    insertFunctionAt(func: Function, index: number): Function;
    /**
     * 添加函数
     * @internal
     * @param name 函数名称，如果不填会自动生成一个唯一名称
     */
    _addFunction(name?: string): Function;
    /**
     * 添加函数
     * @internal
     * @param funcOptions 函数参数
     */
    _addFunction(funcOptions: Partial<Function>): Function;
    /**
     * 添加函数
     * @internal
     * @param func 已有的函数实例
     */
    _addFunction(func: Function): Function;
    /**
     * 添加函数
     * @internal
     * @param name 函数名称，如果不填会自动生成一个唯一名称
     */
    addFunction(name?: string): Function;
    /**
     * 添加函数
     * @param funcOptions 函数参数
     */
    addFunction(funcOptions: Partial<Function>): Function;
    /**
     * 添加函数
     * @param func 已有的函数实例
     */
    addFunction(func: Function): Function;
    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 变量名称，如果不填会自动生成一个唯一名称
     */
    _insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variableOptions 变量参数
     */
    _insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variable 已有的变量实例
     */
    _insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
    /**
     * 插入变量
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @param variableOptions 变量参数
     */
    insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @param variable 已有的变量实例
     */
    insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    _addVariableInFrontendVariables(name?: string): Variable;
    /**
     * 添加变量
     * @internal
     * @param variableOptions 变量参数
     */
    _addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @internal
     * @param variable 已有的变量实例
     */
    _addVariableInFrontendVariables(variable: Variable): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    addVariableInFrontendVariables(name?: string): Variable;
    /**
     * 添加变量
     * @param variableOptions 变量参数
     */
    addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @param variable 已有的变量实例
     */
    addVariableInFrontendVariables(variable: Variable): Variable;
    /**
     * 插入变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    _insertVariableInVariablesAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variableOptions 变量参数
     */
    _insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @internal
     * @param variable 已有的变量实例
     */
    _insertVariableInVariablesAt(variable: Variable, index: number): Variable;
    /**
     * 插入变量
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    insertVariableInVariablesAt(name: string, index: number): Variable;
    /**
     * 插入变量
     * @param variableOptions 变量参数
     */
    insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
    /**
     * 插入变量
     * @param variable 已有的变量实例
     */
    insertVariableInVariablesAt(variable: Variable, index: number): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    _addVariableInVariables(name?: string): Variable;
    /**
     * 添加变量
     * @internal
     * @param variableOptions 变量参数
     */
    _addVariableInVariables(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @internal
     * @param variable 已有的变量实例
     */
    _addVariableInVariables(variable: Variable): Variable;
    /**
     * 添加变量
     * @internal
     * @param name 变量名称，如果不填会自动生成一个唯一名称
     */
    addVariableInVariables(name?: string): Variable;
    /**
     * 添加变量
     * @param variableOptions 变量参数
     */
    addVariableInVariables(variableOptions: Partial<Variable>): Variable;
    /**
     * 添加变量
     * @param variable 已有的变量实例
     */
    addVariableInVariables(variable: Variable): Variable;
    getViewComponentDeclarationExistingNames(excludedList?: Array<ViewComponentDeclaration>): string[];
    getViewComponentDeclarationUniqueName(name?: string): string;
    /**
     * 插入页面组件
     * @internal
     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
     */
    _insertViewComponentDeclarationAt(name: string, index: number): ViewComponentDeclaration;
    /**
     * 插入页面组件
     * @internal
     * @param viewComponentDeclarationOptions 页面组件参数
     */
    _insertViewComponentDeclarationAt(viewComponentDeclarationOptions: Partial<ViewComponentDeclaration>, index: number): ViewComponentDeclaration;
    /**
     * 插入页面组件
     * @internal
     * @param viewComponentDeclaration 已有的页面组件实例
     */
    _insertViewComponentDeclarationAt(viewComponentDeclaration: ViewComponentDeclaration, index: number): ViewComponentDeclaration;
    /**
     * 插入页面组件
     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
     */
    insertViewComponentDeclarationAt(name: string, index: number): ViewComponentDeclaration;
    /**
     * 插入页面组件
     * @param viewComponentDeclarationOptions 页面组件参数
     */
    insertViewComponentDeclarationAt(viewComponentDeclarationOptions: Partial<ViewComponentDeclaration>, index: number): ViewComponentDeclaration;
    /**
     * 插入页面组件
     * @param viewComponentDeclaration 已有的页面组件实例
     */
    insertViewComponentDeclarationAt(viewComponentDeclaration: ViewComponentDeclaration, index: number): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @internal
     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
     */
    _addViewComponentDeclaration(name?: string): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @internal
     * @param viewComponentDeclarationOptions 页面组件参数
     */
    _addViewComponentDeclaration(viewComponentDeclarationOptions: Partial<ViewComponentDeclaration>): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @internal
     * @param viewComponentDeclaration 已有的页面组件实例
     */
    _addViewComponentDeclaration(viewComponentDeclaration: ViewComponentDeclaration): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @internal
     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
     */
    addViewComponentDeclaration(name?: string): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @param viewComponentDeclarationOptions 页面组件参数
     */
    addViewComponentDeclaration(viewComponentDeclarationOptions: Partial<ViewComponentDeclaration>): ViewComponentDeclaration;
    /**
     * 添加页面组件
     * @param viewComponentDeclaration 已有的页面组件实例
     */
    addViewComponentDeclaration(viewComponentDeclaration: ViewComponentDeclaration): ViewComponentDeclaration;
    getProcessComponentExistingNames(excludedList?: Array<ProcessComponent>): string[];
    getProcessComponentUniqueName(name?: string): string;
    /**
     * 插入流程组件
     * @internal
     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
     */
    _insertProcessComponentAt(name: string, index: number): ProcessComponent;
    /**
     * 插入流程组件
     * @internal
     * @param processComponentOptions 流程组件参数
     */
    _insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
    /**
     * 插入流程组件
     * @internal
     * @param processComponent 已有的流程组件实例
     */
    _insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
    /**
     * 插入流程组件
     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
     */
    insertProcessComponentAt(name: string, index: number): ProcessComponent;
    /**
     * 插入流程组件
     * @param processComponentOptions 流程组件参数
     */
    insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
    /**
     * 插入流程组件
     * @param processComponent 已有的流程组件实例
     */
    insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
    /**
     * 添加流程组件
     * @internal
     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
     */
    _addProcessComponent(name?: string): ProcessComponent;
    /**
     * 添加流程组件
     * @internal
     * @param processComponentOptions 流程组件参数
     */
    _addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
    /**
     * 添加流程组件
     * @internal
     * @param processComponent 已有的流程组件实例
     */
    _addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
    /**
     * 添加流程组件
     * @internal
     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
     */
    addProcessComponent(name?: string): ProcessComponent;
    /**
     * 添加流程组件
     * @param processComponentOptions 流程组件参数
     */
    addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
    /**
     * 添加流程组件
     * @param processComponent 已有的流程组件实例
     */
    addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
    /**
     * 删除命名空间
     * @param name 命名空间名称
     */
    removeNamespace(name: string): void;
    /**
     * 删除命名空间
     * @param namespace 已有的命名空间实例
     */
    removeNamespace(namespace: Namespace): 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 数据结构名称
     */
    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 函数名称
     */
    removeFunction(name: string): void;
    /**
     * 删除函数
     * @param func 已有的函数实例
     */
    removeFunction(func: Function): 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 变量名称
     */
    removeVariableInFrontendVariables(name: string): void;
    /**
     * 删除变量
     * @param variable 已有的变量实例
     */
    removeVariableInFrontendVariables(variable: Variable): void;
    /**
     * 删除变量
     * @param name 变量名称
     */
    removeVariableInVariables(name: string): void;
    /**
     * 删除变量
     * @param variable 已有的变量实例
     */
    removeVariableInVariables(variable: Variable): void;
    /**
     * 删除页面组件
     * @param name 页面组件名称
     */
    removeViewComponentDeclaration(name: string): void;
    /**
     * 删除页面组件
     * @param viewComponentDeclaration 已有的页面组件实例
     */
    removeViewComponentDeclaration(viewComponentDeclaration: ViewComponentDeclaration): void;
    /**
     * 删除流程组件
     * @param name 流程组件名称
     */
    removeProcessComponent(name: string): void;
    /**
     * 删除流程组件
     * @param processComponent 已有的流程组件实例
     */
    removeProcessComponent(processComponent: ProcessComponent): void;
    findEnumByName(name: string): Enum;
    findStructureByName(name: string): Structure;
    findLogicByName(name: string): Logic;
    findFunctionByName(name: string): Function;
    path: string;
    /**
     * 获取命名空间
     */
    getNamespace(): string;
    /**
     * 获取命名空间
     */
    getTsNamespace(): string;
    getEmbeddedFilePrefix(): string;
    /**
     * 生成宿主语言的文件路径
     * @param name 一般不用传，用于 rename
     */
    getEmbeddedFilePath(): string;
    toEmbeddedTSFile(): Embedded.TSFileGenerator<Namespace>;
    getFullyQualifiedNameSpace(): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    findChild(name: string): Namespace;
    findLogic(name: string): Logic;
    getLogicExistingTitles(excludedList?: Array<Logic>): string[];
    removeLogicExpectInterface(options: string | Logic): void;
}
export default Namespace;
//# sourceMappingURL=Namespace__.d.ts.map