@lcap/nasl 2.22.2-beta.3 → 2.22.2-beta.5

package/out/concepts/Process__.d.ts

@@ -0,0 +1,614 @@
+import { TranslatorState } from '../translator';
+import Logic from './Logic__';
+import { EventPayload, Params } from '../common/EventEmitter';
+import BaseNode from '../common/BaseNode';
+import BindEvent from './BindEvent__';
+import Param from './Param__';
+import Return from './Return__';
+import Constant from './Constant__';
+import ProcessElement from './ProcessElement__';
+import Module from './Module__';
+import App from './App__';
+/**
+ * 流程
+ */
+export declare class Process extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName = "Process";
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Process';
+    /**
+     * 流程名称
+     */
+    name: string;
+    /**
+     * 流程标题
+     */
+    title: string;
+    /**
+     * 流程描述
+     */
+    description: string;
+    /**
+     * 元素绑定事件列表
+     */
+    bindEvents: Array<BindEvent>;
+    /**
+     * 输入参数列表
+     */
+    params: Array<Param>;
+    /**
+     * 输出参数列表
+     */
+    returns: Array<Return>;
+    /**
+     * 常量列表
+     */
+    constants: Array<Constant>;
+    /**
+     * 流程元素列表
+     */
+    elements: Array<ProcessElement>;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    /**
+     * 祖先 App
+     */
+    get app(): App;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Process>);
+    static from(source: any, parentNode?: any, parentKey?: string): Process;
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete(): Params;
+    /**
+     * 设置流程名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置流程标题
+     */
+    setTitle(title: string): void;
+    /**
+     * 设置流程描述
+     */
+    setDescription(description: string): void;
+    getBindEventExistingNames(excludedList?: Array<BindEvent>): string[];
+    getBindEventUniqueName(name?: string): string;
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+    */
+    _insertBindEventAt(name: string, index: number): BindEvent;
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param bindEventOptions 元素绑定事件参数
+    */
+    _insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param bindEvent 已有的元素绑定事件实例
+    */
+    _insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    insertBindEventAt(name: string, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    _addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    _addBindEvent(bindEvent: BindEvent): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    addBindEvent(bindEvent: BindEvent): BindEvent;
+    getParamExistingNames(excludedList?: Array<Param>): string[];
+    getParamUniqueName(name?: string): string;
+    /**
+    * 插入输入参数
+    * @internal
+    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertParamAt(name: string, index: number): Param;
+    /**
+    * 插入输入参数
+    * @internal
+    * @param paramOptions 输入参数参数
+    */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+    * 插入输入参数
+    * @internal
+    * @param param 已有的输入参数实例
+    */
+    _insertParamAt(param: Param, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+    getReturnExistingNames(excludedList?: Array<Return>): string[];
+    getReturnUniqueName(name?: string): string;
+    /**
+    * 插入输出参数
+    * @internal
+    * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertReturnAt(name: string, index: number): Return;
+    /**
+    * 插入输出参数
+    * @internal
+    * @param retOptions 输出参数参数
+    */
+    _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+    * 插入输出参数
+    * @internal
+    * @param ret 已有的输出参数实例
+    */
+    _insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertReturnAt(name: string, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param retOptions 输出参数参数
+     */
+    insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param ret 已有的输出参数实例
+     */
+    insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _addReturn(ret: Return): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @param retOptions 输出参数参数
+     */
+    addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @param ret 已有的输出参数实例
+     */
+    addReturn(ret: Return): Return;
+    getConstantExistingNames(excludedList?: Array<Constant>): string[];
+    getConstantUniqueName(name?: string): string;
+    /**
+    * 插入常量
+    * @internal
+    * @param name 常量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertConstantAt(name: string, index: number): Constant;
+    /**
+    * 插入常量
+    * @internal
+    * @param constantOptions 常量参数
+    */
+    _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+    /**
+    * 插入常量
+    * @internal
+    * @param constant 已有的常量实例
+    */
+    _insertConstantAt(constant: Constant, index: number): Constant;
+    /**
+     * 插入常量
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    insertConstantAt(name: string, index: number): Constant;
+    /**
+     * 插入常量
+     * @param constantOptions 常量参数
+     */
+    insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+    /**
+     * 插入常量
+     * @param constant 已有的常量实例
+     */
+    insertConstantAt(constant: Constant, index: number): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    _addConstant(name?: string): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
+    _addConstant(constantOptions: Partial<Constant>): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
+    _addConstant(constant: Constant): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    addConstant(name?: string): Constant;
+    /**
+     * 添加常量
+     * @param constantOptions 常量参数
+     */
+    addConstant(constantOptions: Partial<Constant>): Constant;
+    /**
+     * 添加常量
+     * @param constant 已有的常量实例
+     */
+    addConstant(constant: Constant): Constant;
+    getElementExistingNames(excludedList?: Array<ProcessElement>): string[];
+    getElementUniqueName(name?: string): string;
+    /**
+    * 插入流程元素
+    * @internal
+    * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+    */
+    _insertElementAt(name: string, index: number): ProcessElement;
+    /**
+    * 插入流程元素
+    * @internal
+    * @param elementOptions 流程元素参数
+    */
+    _insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+    /**
+    * 插入流程元素
+    * @internal
+    * @param element 已有的流程元素实例
+    */
+    _insertElementAt(element: ProcessElement, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    insertElementAt(name: string, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param elementOptions 流程元素参数
+     */
+    insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param element 已有的流程元素实例
+     */
+    insertElementAt(element: ProcessElement, index: number): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    _addElement(name?: string): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param elementOptions 流程元素参数
+     */
+    _addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param element 已有的流程元素实例
+     */
+    _addElement(element: ProcessElement): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    addElement(name?: string): ProcessElement;
+    /**
+     * 添加流程元素
+     * @param elementOptions 流程元素参数
+     */
+    addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+    /**
+     * 添加流程元素
+     * @param element 已有的流程元素实例
+     */
+    addElement(element: ProcessElement): ProcessElement;
+    /**
+    * 删除元素绑定事件
+    * @param name 元素绑定事件名称
+    */
+    removeBindEvent(name: string): void;
+    /**
+     * 删除元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    removeBindEvent(bindEvent: BindEvent): void;
+    __removeBindEvent(bindEvent: BindEvent): Params;
+    /**
+    * 删除输入参数
+    * @param name 输入参数名称
+    */
+    removeParam(name: string): void;
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+    __removeParam(param: Param): Params;
+    /**
+    * 删除输出参数
+    * @param name 输出参数名称
+    */
+    removeReturn(name: string): void;
+    /**
+     * 删除输出参数
+     * @param ret 已有的输出参数实例
+     */
+    removeReturn(ret: Return): void;
+    __removeReturn(ret: Return): Params;
+    /**
+    * 删除常量
+    * @param name 常量名称
+    */
+    removeConstant(name: string): void;
+    /**
+     * 删除常量
+     * @param constant 已有的常量实例
+     */
+    removeConstant(constant: Constant): void;
+    __removeConstant(constant: Constant): Params;
+    /**
+    * 删除流程元素
+    * @param name 流程元素名称
+    */
+    removeElement(name: string): void;
+    /**
+     * 删除流程元素
+     * @param element 已有的流程元素实例
+     */
+    removeElement(element: ProcessElement): void;
+    __removeProcessElement(element: ProcessElement): Params;
+    onChange($event?: EventPayload): void;
+    _removeElement(element: ProcessElement): {
+        propertyName: string;
+        index: number;
+    };
+    getVarExistingNames(excludedList?: Array<Param | Return | Constant | ProcessElement>): string[];
+    getNamespace(ns: string): string;
+    getEmbeddedFilePath(name?: string): string;
+    genExclusiveGatewayLogic(elem: ProcessElement): Logic;
+    get logics(): Logic[];
+    /**
+     * 获取当前逻辑下所有elements上bindEvents下的logic
+     */
+    elementLogicRoot: any[];
+    getElementLogicRoot(): void;
+    toUserTaskPropertyGetterTS(userTask: ProcessElement): string;
+    toEmbeddedTS(state?: TranslatorState): string;
+    toEmbeddedTSFile(): {
+        code: string;
+        filePath: string;
+        sourceMap: import("../translator").SourceMap;
+    };
+    static getDefaultOptions(): {
+        constants: {
+            concept: string;
+            name: string;
+            typeAnnotation: {
+                concept: string;
+                typeKind: string;
+                typeNamespace: string;
+                typeName: string;
+            };
+        }[];
+        elements: ({
+            concept: string;
+            name: string;
+            type: string;
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            bindAttrs: {
+                concept: string;
+                name: string;
+                assignee: {
+                    concept: string;
+                };
+            }[];
+            constants: {
+                concept: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            concept: string;
+            name: string;
+            type: string;
+            title: string;
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            bindAttrs: {
+                concept: string;
+                name: string;
+                assignee: {
+                    concept: string;
+                };
+            }[];
+            constants: {
+                concept: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            concept: string;
+            name: string;
+            type: string;
+            title: string;
+            returns: {
+                concept: string;
+                description: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            concept: string;
+            name: string;
+            type: string;
+            sourceRef: string;
+            targetRef: string;
+            waypoints: {
+                x: number;
+                y: number;
+            }[];
+            bounds?: undefined;
+        })[];
+    };
+}
+export default Process;