@lcap/nasl 2.22.1 → 2.22.2

package/out/concepts/OverriddenLogic__.d.ts

@@ -0,0 +1,643 @@
+import { TranslatorState } from '../translator';
+import ForEachStatement from './ForEachStatement__';
+import Assignment from './Assignment__';
+import BatchAssignment from './BatchAssignment__';
+import MatchCase from './MatchCase__';
+import Logic from './Logic__';
+import { EventPayload, Params } from '../common/EventEmitter';
+import BaseNode from '../common/BaseNode';
+import Transactional from './Transactional__';
+import TypeParam from './TypeParam__';
+import Param from './Param__';
+import Return from './Return__';
+import Variable from './Variable__';
+import LogicItem from './LogicItem__';
+import Module from './Module__';
+import View from './View__';
+import ProcessElement from './ProcessElement__';
+import App from './App__';
+import Frontend from './Frontend__';
+import Process from './Process__';
+/**
+ * 逻辑
+ */
+export declare class OverriddenLogic extends BaseNode {
+    /**
+     * 产品概念
+     */
+    concept: 'OverriddenLogic';
+    /**
+     * overriddenModule
+     */
+    overriddenModule: string;
+    /**
+     * 逻辑名称
+     */
+    name: string;
+    /**
+     * 逻辑描述
+     */
+    description: string;
+    /**
+     * triggerType
+     */
+    triggerType: string;
+    /**
+     * cron
+     */
+    cron: string;
+    /**
+     * 事务
+     */
+    transactional: Transactional;
+    /**
+     * 编译器信息
+     */
+    compilerInfoMap: {
+        java?: {
+            packageName: string;
+            className: string;
+        };
+    };
+    /**
+     * 类型参数列表
+     */
+    typeParams: Array<TypeParam>;
+    /**
+     * 输入参数列表
+     */
+    params: Array<Param>;
+    /**
+     * 输出参数列表
+     */
+    returns: Array<Return>;
+    /**
+     * 变量列表
+     */
+    variables: Array<Variable>;
+    /**
+     * 逻辑项列表
+     */
+    body: Array<LogicItem>;
+    /**
+     * 逻辑项列表
+     */
+    playground: Array<LogicItem>;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    /**
+     * 祖先 App
+     */
+    get app(): App;
+    /**
+     * 祖先 View
+     */
+    get view(): View;
+    /**
+     * 祖先 Frontend
+     */
+    get frontend(): Frontend;
+    /**
+     * 祖先 ProcessElement
+     */
+    get processElement(): ProcessElement;
+    /**
+     * 祖先 Process
+     */
+    get process(): Process;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<OverriddenLogic>);
+    getClassName(): string;
+    static from(source: any, parentNode?: any, parentKey?: string): OverriddenLogic;
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete(): Params;
+    /**
+     * 设置overriddenModule
+     */
+    setOverriddenModule(overriddenModule: string): void;
+    /**
+     * 设置逻辑名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置逻辑描述
+     */
+    setDescription(description: string): void;
+    /**
+     * 设置triggerType
+     */
+    setTriggerType(triggerType: string): void;
+    /**
+     * 设置cron
+     */
+    setCron(cron: string): void;
+    /**
+     * 设置事务
+     */
+    setTransactional(transactional: Transactional): void;
+    getTypeParamExistingNames(excludedList?: Array<TypeParam>): string[];
+    getTypeParamUniqueName(name?: string): string;
+    /**
+    * 插入类型参数
+    * @internal
+    * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertTypeParamAt(name: string, index: number): TypeParam;
+    /**
+    * 插入类型参数
+    * @internal
+    * @param typeParamOptions 类型参数参数
+    */
+    _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+    /**
+    * 插入类型参数
+    * @internal
+    * @param typeParam 已有的类型参数实例
+    */
+    _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertTypeParamAt(name: string, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addTypeParam(name?: string): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
+    _addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
+    _addTypeParam(typeParam: TypeParam): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    addTypeParam(name?: string): TypeParam;
+    /**
+     * 添加类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+    /**
+     * 添加类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    addTypeParam(typeParam: TypeParam): TypeParam;
+    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;
+    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;
+    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;
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInBody(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInBody(logicItem: LogicItem): LogicItem;
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInPlayground(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInPlayground(logicItem: LogicItem): LogicItem;
+    /**
+    * 删除事务
+    * @param name 事务名称
+    */
+    removeTransactional(name: string): void;
+    /**
+     * 删除事务
+     * @param transactional 已有的事务实例
+     */
+    removeTransactional(transactional: Transactional): void;
+    __removeTransactional(transactional: Transactional): Params;
+    /**
+    * 删除类型参数
+    * @param name 类型参数名称
+    */
+    removeTypeParam(name: string): void;
+    /**
+     * 删除类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    removeTypeParam(typeParam: TypeParam): void;
+    __removeTypeParam(typeParam: TypeParam): 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 变量名称
+    */
+    removeVariable(name: string): void;
+    /**
+     * 删除变量
+     * @param variable 已有的变量实例
+     */
+    removeVariable(variable: Variable): void;
+    __removeVariable(variable: Variable): Params;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInBody(logicItem: LogicItem): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInPlayground(logicItem: LogicItem): void;
+    __removeLogicItem(logicItem: LogicItem): Params;
+    get calleewholeKey(): string;
+    setCronAndTriggerType(cron: string, triggerType: string): void;
+    /**
+     * 创建的时候 打开事务 通过开关设置数据库事务
+     */
+    openTransactional(flag: boolean): void;
+    findLogicItemByConcept(concept: string): LogicItem;
+    onChange($event?: EventPayload): void;
+    getVarExistingNames(excludedList?: Array<Param | Return | Variable>): any[];
+    toJSContent(code: string, state?: TranslatorState): string;
+    toJS(state?: TranslatorState, type?: string): string;
+    toProcessService(): {
+        config: {
+            serviceType: string;
+        };
+        url: {
+            method: string;
+            path: string;
+        };
+    };
+    toService(): {
+        config: {
+            serviceType: string;
+        };
+        url: {
+            method: string;
+            path: string;
+        };
+    };
+    toEmbeddedTSInProcess(state?: TranslatorState, prependCode?: string, noName?: boolean, prefix?: boolean): string;
+    toEmbeddedTSNoExport(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState, prefix?: string): string;
+    getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string;
+    handleReplaceCode(code: string, variable: string, replaceCode: string): string;
+    handleForEachCode(code: string, forEachStatement: ForEachStatement): string;
+    handleMatchCaseCode(code: string, matchCase: MatchCase): string;
+    getNamespace(): string;
+    getTsNamespace(): string;
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name?: string): string;
+    toEmbeddedTSFile(): {
+        code: string;
+        filePath: string;
+        sourceMap: import("../translator").SourceMap;
+    };
+    static getDefaultOptions(): {
+        body: {
+            concept: string;
+            label: string;
+            kind: string;
+            type: string;
+        }[];
+    };
+    saveStructureOfCallQueryComponents(root?: BaseNode | Logic): Promise<void>;
+    setTransactionEnabled(flag: boolean): void;
+    fake: boolean;
+    getPath: () => string;
+    delete(): void;
+    haveError: boolean;
+    isSmpty: boolean;
+    get pathName(): string;
+    getEventLogicName(type?: string): string;
+    virtualParams: Array<Param>;
+    get getLogicBelongTo(): string;
+    static checkLogicReturnTypeHasError(logic: Logic): boolean;
+    get getIsEmptyLogic(): boolean;
+    getOverriddenDepLogic(): Logic;
+}
+export default OverriddenLogic;