udm-rules-vue 0.0.2 → 0.0.3

package/dist/model/BO.d.ts

@@ -3,6 +3,7 @@ export declare const UTILS_CLASSNAME = "udm.Utils";
 export declare const COMMON_UTILS_CLASSNAME = "udm.CommonUtils";
 export declare const COMPARE_UTILS_CLASSNAME = "udm.CompareUtils";
 export declare const COMMON_ACTION_UTILS_CLASSNAME = "udm.ActionUtils";
+export declare const COMMON_SCORECARD_UTILS_CLASSNAME = "udm.ScorecardUtils";
 export declare const VARIABLE_ASSIGN_METHOD = "variableAssign";
 export declare const FROM_LIST = "\u6765\u81EA(in)";
 export declare const ONLY_VARIABLE = "umd.OnlyVariable";
@@ -14,21 +15,34 @@ export declare class VariableDefine {
      */
     fullClassName: string;
     datatype: Datatype;
+    genericity?: string;
     /**
      * 描述名称，在规则中使用时用''包裹
      */
     verbalization: string;
+    /**
+     *  变量作用域，in表示只能在条件部分使用，out表示只能在动作部分使用，in_out表示在条件和动作部分都可以使用
+     */
+    scope: VariableScope;
+    /**
+     * 初始值
+     */
     initialValue: string | undefined;
     documentation: string | undefined;
     /**
      * 关于当前对象的提示信息，用于代码完成时提示项或hover项提示
      */
     private tip;
-    constructor(name: string, type: string, verbalization: string, path: string, genericity?: string);
+    constructor(name: string, type: string, scope: VariableScope, verbalization: string, path: string, genericity?: string);
     buildVerbalizationName(): string;
     buildName(): string;
     buildTip(): string;
 }
+export declare enum VariableScope {
+    IN = "IN",
+    OUT = "OUT",
+    IN_OUT = "IN_OUT"
+}
 export declare class ObjectDefine {
     verbalization: string;
     /**

package/dist/model/Datatype.d.ts

@@ -82,3 +82,4 @@ export declare enum TypeNumber {
     ANY = 2
 }
 export declare const getOnlyVariableDatatype: () => Datatype;
+export declare const typeIsMap: (datatype: string) => boolean;

package/dist/model/NavigationTree.d.ts

@@ -78,9 +78,10 @@ declare class NavigationTree {
      */
     enumClassNameMap: Map<string, FieldDefine[]>;
     /**
-     * 用来存储所有的枚举类型的 verbalization，key为枚举属性对应的verbalization，value为枚举属性对象，该集合主要用于语法解析，让词法解析器可以快速判断当前Token是否为一个枚举类型的静态属性。
+     * 用来存储所有的枚举类型的 verbalization，key为枚举属性对应的verbalization，value为枚举属性对象，
+     * 因为可能存在同名的枚举值，所以这里的value为FieldDefine数组，该集合主要用于语法解析，让词法解析器可以快速判断当前Token是否为一个枚举类型的静态属性。
      */
-    enumVerbalizationMap: Map<string, FieldDefine>;
+    enumVerbalizationMap: Map<string, FieldDefine[]>;
     private clean;
     /**
      * 根据给出的预定义变量名，返回可能存在的预定义变量对应的对象信息
@@ -97,7 +98,6 @@ declare class NavigationTree {
     /**
      * 将一个业务对象中的所有枚举字段，添加到枚举字段集合中，便于在解析及代码提示时使用
      * @param objectDefine 业务对象定义
-     * @param enumVerbalizationSet 一个用来防止重复枚举 verbalization 的Set
      */
     private buildObjectDefineEnumFields;
     /**

package/dist/model/VscodeBuiltinObjectsLoader.d.ts

@@ -8,7 +8,9 @@ export default class VscodeBuiltinObjectsLoader {
     private readBasicObjectBomFile;
     private readConstantsObjectBomFile;
     private readStaticMethodBomFile;
+    private readScorecardBomFile;
     private readBasicObjectVocFile;
     private readConstantsObjectVocFile;
     private readStaticMethodVocFile;
+    private readScorecardVocFile;
 }

package/dist/model/WebBuiltinObjectsLoader.d.ts

@@ -2,12 +2,14 @@ import { ObjectDefine } from './BO';
 export default class WebBuiltinObjectsLoader {
     private declareMap;
     private vocFilesReader;
-    constructor();
+    constructor(inScorecard: boolean);
     getObjectDefines(): ObjectDefine[];
     private readBasicObjectBomFile;
     private readConstantsObjectBomFile;
     private readStaticMethodBomFile;
+    private readScorecardBomFile;
     private readBasicObjectVocFile;
     private readStaticMethodVocFile;
     private readConstantsVocFile;
+    private readScorecardVocFile;
 }

package/dist/model/WebViewBomFilesReader.d.ts

@@ -1,2 +1,2 @@
 export declare const resetBomFilesLoadedFlag: () => void;
-export declare const parseAllBomFilesForWebView: (bomFilesData: Record<string, Record<string, string>[]>) => void;
+export declare const parseAllBomFilesForWebView: (bomFilesData: Record<string, Record<string, string>[]>, inScorecard: boolean) => void;

package/dist/model/expression/ArithExpression.d.ts

@@ -1,10 +1,11 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { Expression } from './Expression';
 import { PredefineExpression } from './PredefineExpression';
 export declare class ArithExpression extends Expression {
     private expressions;
     private types;
     constructor(expressions: Expression[], types: ArithType[], text: string);
-    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
     private buildScript;
     buildArithSymbol(type: ArithType): "*" | "/" | "+" | "-" | "%";
 }

package/dist/model/expression/BatchExpression.d.ts

@@ -1,10 +1,11 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { Expression } from './Expression';
 import { PredefineExpression } from './PredefineExpression';
 export declare class BatchExpression extends Expression {
     private expressions;
     private type;
     constructor(expressions: Expression[], type: BatchType, text: string);
-    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
     private buildScript;
 }
 export declare enum BatchType {

package/dist/model/expression/Expression.d.ts

@@ -1,8 +1,9 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { PredefineExpression } from './PredefineExpression';
 export declare abstract class Expression {
     private text;
     constructor(text: string);
-    abstract toCompileScript(predefineVariableMap: Map<string, PredefineExpression>): string;
+    abstract toCompileScript(predefineVariableMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
     getText(): string;
 }
 export declare const buildIndent: (level: number) => string;

package/dist/model/expression/MethodExpression.d.ts

@@ -1,12 +1,14 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { FieldDefine, MethodDefine } from '../BO';
 import { Expression } from './Expression';
 import { PredefineExpression } from './PredefineExpression';
 export declare class MethodExpression extends Expression {
     private define;
     private parameters;
-    constructor(define: MethodDefine | FieldDefine, parameters: Expression[], text: string);
-    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
-    buildScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    private fieldDefines;
+    constructor(define: MethodDefine | FieldDefine, parameters: Expression[], fieldDefines: FieldDefine[], text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
+    private buildScript;
     getParameters(): Expression[];
     getDefine(): MethodDefine | FieldDefine;
 }

package/dist/model/expression/PredefineExpression.d.ts

@@ -1,3 +1,4 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { BusinessObject } from '../BO';
 import { Expression } from './Expression';
 export declare class PredefineExpression extends Expression {
@@ -10,7 +11,7 @@ export declare class PredefineExpression extends Expression {
     condition?: Expression;
     private hashCode?;
     constructor(name: string, text: string);
-    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
     private buildPredefineValue;
     private buildScript;
     getHashCode(): string | undefined;

package/dist/model/expression/RuleExpression.d.ts

@@ -1,3 +1,4 @@
+import { CompileContext } from '../../compile/FileCompiler';
 import { Expression } from './Expression';
 import { PredefineExpression } from './PredefineExpression';
 export declare class RuleExpression {
@@ -5,8 +6,8 @@ export declare class RuleExpression {
     ifExpression?: Expression;
     thenExpression?: Expression[];
     elseExpression?: Expression[];
-    toScript(name: string, predefineVariableMap: Map<string, PredefineExpression>): string;
-    buildElseRule(name: string, predefineVariableMap: Map<string, PredefineExpression>): string;
+    toScript(name: string, predefineVariableMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
+    buildElseRule(name: string, predefineVariableMap: Map<string, PredefineExpression>, compileContext: CompileContext): string;
 }
 export declare class RuleProperty {
     private name;

package/dist/model/expression/compile/commonMethodScriptCompile.d.ts

@@ -1,4 +1,5 @@
+import { CompileContext } from '../../../compile/FileCompiler';
 import { ObjectMethod } from '../../BO';
 import { Expression } from '../Expression';
 import { PredefineExpression } from '../PredefineExpression';
-export declare const doCompileCommonMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>) => string;
+export declare const doCompileCommonMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext) => string;

package/dist/model/expression/compile/compareMethodScriptCompile.d.ts

@@ -1,4 +1,5 @@
+import { CompileContext } from '../../../compile/FileCompiler';
 import { ObjectMethod } from '../../BO';
 import { Expression } from '../Expression';
 import { PredefineExpression } from '../PredefineExpression';
-export declare const doCompileCompareMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>) => string;
+export declare const doCompileCompareMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext) => string;

package/dist/monaco/ExpressionFinder.d.ts

@@ -1,6 +1,8 @@
 import { ParserRuleContext, TerminalNode } from 'antlr4ng';
 import { ExpressionContext, VariableContext } from '../grammar/rule/RuleParser';
+import { FieldDefine, MethodDefine } from '../model/BO';
 import { Datatype } from '../model/Datatype';
+import { NavigationNode } from '../model/NavigationTree';
 import { Expression } from '../model/expression/Expression';
 import { VariableExpression } from '../model/expression/VariableExpression';
 declare class ExpressionFinder {
@@ -10,7 +12,7 @@ declare class ExpressionFinder {
     private parseMethod;
     private findTargetMethodNodesByDescriptor;
     private doFindTargetMethodNodesByDescriptor;
-    private findTargetDefine;
+    findTargetDefine(methodNodes?: NavigationNode[]): FieldDefine | MethodDefine | undefined;
     private parseBasic;
     private parseObject;
     private parsePlaceholder;
@@ -18,6 +20,7 @@ declare class ExpressionFinder {
     private parseCurrentLoopItemObject;
     private parseLiteral;
     parseVariable(variableContext: VariableContext, finderContext: ExpressionFinderContext): VariableExpression | undefined;
+    findMethodFields(methodDefine: MethodDefine, fields: TerminalNode[]): FieldDefine[];
     private findTargetFieldNode;
 }
 export declare class ExpressionFinderContext {

package/dist/monaco/MonacoHoverProvider.d.ts

@@ -12,8 +12,6 @@ export declare class MonacoHoverProvider implements monaco.languages.HoverProvid
     private buildObjectFieldTip;
     private findTargetVariableFields;
     private buildMethodTip;
-    private buildMatchedMethodsDocumentation;
-    private findTagetMethods;
     private caretInTerminalNode;
     private caretInContext;
 }

package/dist/monaco/parseTargetPartRuleScript.d.ts

@@ -1,9 +1,9 @@
 import { CommonTokenStream } from 'antlr4ng';
-import { SemanticErrorData } from '../../npmconfig/dist';
 import { default as BoostRuleLexer } from '../grammar/parser/BoostRuleLexer';
 import { default as BoostRuleParser } from '../grammar/parser/BoostRuleParser';
 import { Datatype } from '../model/Datatype';
 import { RulePart } from '../utils';
+import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
 export declare const parseTargetPartRuleScript: (text: string, part: RulePart, avaliablePredefineVariablesMap: Map<string, Datatype>, errorList: SemanticErrorData[]) => ParsePartResult;
 export type ParsePartResult = {
     lexer: BoostRuleLexer;

package/dist/projectprops/ProjectProperties.d.ts

@@ -3,8 +3,10 @@ declare class ProjectProperties {
     private sourceFolder;
     categories: Category[];
     parameters: Parameter[];
+    rulesetProperties: any;
     getUuid(): string;
     setUuid(uuid: string): void;
+    getRulesetProperties(): any;
     getSourceFolder(): string;
     checkValid(): string | undefined;
     toXml(): string;

package/dist/projectprops/ProjectPropertiesEditor.vue.d.ts

@@ -53,5 +53,25 @@ declare const _default: DefineComponent<__VLS_Props, {
         setReadonlyMode: (value: boolean) => void;
         getReadonlyMode: () => boolean;
     }, {}, {}, {}, {}> | null;
+    rulesetRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        darkMode: boolean;
+        readonly?: boolean;
+    }> & Readonly<{}>, {
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        darkMode: boolean;
+        readonly?: boolean;
+    }> & Readonly<{}>, {
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+    }, {}, {}, {}, {}> | null;
 }, any>;
 export default _default;

package/dist/projectprops/PureWebProjectPropertiesEditor.vue.d.ts

@@ -77,6 +77,26 @@ declare const _default: DefineComponent<__VLS_Props, {
             setReadonlyMode: (value: boolean) => void;
             getReadonlyMode: () => boolean;
         }, {}, {}, {}, {}> | null;
+        rulesetRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+            darkMode: boolean;
+            readonly?: boolean;
+        }> & Readonly<{}>, {
+            setReadonlyMode: (value: boolean) => void;
+            getReadonlyMode: () => boolean;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            darkMode: boolean;
+            readonly?: boolean;
+        }> & Readonly<{}>, {
+            setReadonlyMode: (value: boolean) => void;
+            getReadonlyMode: () => boolean;
+        }, {}, {}, {}, {}> | null;
     }, any, ComponentProvideOptions, {
         P: {};
         B: {};

package/dist/projectprops/Ruleset.vue.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+    readonly?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    setReadonlyMode: (value: boolean) => void;
+    getReadonlyMode: () => boolean;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/quicktest/TestUtils.d.ts

@@ -14,17 +14,25 @@ export declare class VariableObject {
     datatype: string;
     withInitialScript: boolean;
     genericity?: string;
-    value: string | VariableObject[] | undefined;
+    value: string | VariableObject[] | Map<string, VariableObject> | undefined;
     fields: VariableObject[];
     existFieldsSet: Set<string>;
     constructor(id: string, label: string, datatype: string, withInitialScript: boolean, value?: string);
     buildData(): Record<string, any>;
 }
-export declare const buildVariableObjectsJsonData: (variableObjects: VariableObject[], format?: boolean) => string;
+export declare const buildInputVariables: () => Variable[];
 export declare const buildVariableObjects: (variables: Variable[], quickTestData: string) => {
     variables: VariableObject[];
     invisibleVariables: VariableObject[];
 };
+/**
+ * 解析提交的JSON数据，将其转换为变量对象列表。这里的JSON数据是一个数组，数组中的每一项都是一个对象，对象的key为变量对象的id，value为变量对象的值。
+ * 解析时为了兼容老版本中直接序列化变量对象方式，这里需要判断变量中是否存在withInitialScript以及genericity属性，
+ * 如果存在，就说明是老版本序列化后的对象，直接处理它就好，否则就说明是新版本序列化后的对象，需要根据变量对象的类型进行解析。
+ * @param jsonData 提交的JSON数据
+ * @returns 变量对象列表
+ */
+export declare const parseVariableObjectsToMap: (jsonData: string) => Map<string, VariableObject>;
 export declare const buildVariableObject: (variableObject: VariableObject) => VariableObject;
 export type Variable = {
     id: string;
@@ -35,8 +43,8 @@ export type Variable = {
     genericity?: string;
     defaultValue: string;
 };
-export declare const sampleDatatype: (datatype: string, genericity?: string) => boolean;
+export declare const simpleDatatype: (datatype: string, genericity?: string) => boolean;
 export declare const typeIsCollection: (datatype: string) => boolean;
 export declare const buildObjectFieldsMenu: (variableObject: VariableObject) => MenuItem<string>[];
-export declare const buildSimpleTypeEditor: (type: string) => "number" | "text" | "checkbox" | "date";
+export declare const buildSimpleTypeEditor: (type: string) => "number" | "text" | "checkbox";
 export declare const buildDatatypeGenericity: (datatype: string) => string | undefined;

package/dist/rfl/MenuFactory.d.ts

@@ -1,6 +1,6 @@
-import { default as Connection } from '../components/process/Connection';
-import { default as ProcessNode } from '../components/process/ProcessNode';
-export declare function buildAddNodeMenu(node: ProcessNode, insertConnection?: Connection): {
+import { default as ProcessNodeDef } from './definition/ProcessNodeDef';
+import { default as FlowConnectionDef } from './definition/node/FlowConnectionDef';
+export declare function buildAddNodeMenu(refNode: ProcessNodeDef, refConnection?: FlowConnectionDef): {
     icon: string;
     name: string;
     click: () => void;

package/dist/rfl/config/Enums.d.ts

@@ -1,7 +1,8 @@
 export declare enum ActionType {
     action = "action",
     initial = "initial",
-    final = "final"
+    final = "final",
+    condition = "condition"
 }
 export declare enum ActionLanguage {
     bal = "bal",

package/dist/rfl/data/ActionNodeData.d.ts

@@ -13,6 +13,7 @@ export default class ActionNodeData extends TaskNodeData {
     initialActions: TaskAction;
     /** 最终动作配置 */
     finalActions: TaskAction;
+    constructor(id: string);
     /**
      * 获取任务节点类型
      * @returns 动作任务节点类型

package/dist/rfl/data/ConnectionData.d.ts

@@ -1,3 +1,5 @@
+import { ActionLanguage } from '../config/Enums';
+import { TaskAction } from '../config/TaskAction';
 /**
  * 连接数据类
  * 存储节点间连接的相关数据和配置
@@ -5,18 +7,19 @@
 export default class ConnectionData {
     private id;
     label: string;
-    conditions: string;
+    conditions: TaskAction;
     documentation: string;
     /**
      * 设置连接条件
-     * @param conditions 连接条件字符串
+     * @param language 连接条件语言
+     * @param script 连接条件字符串
      */
-    setConditions(conditions: string): void;
+    setConditions(language: ActionLanguage, script: string): void;
     /**
      * 获取连接条件
      * @returns 连接条件字符串
      */
-    getConditions(): string;
+    getConditions(): TaskAction;
     /**
      * 设置标签
      * @param label 标签字符串

package/dist/rfl/data/NodeData.d.ts

@@ -5,10 +5,15 @@
 export default abstract class NodeData {
     /** 节点唯一标识符 */
     id: string;
+    /** 节点图标 */
+    icon: string;
     /** 节点标签 */
     label: string;
     /** 节点文档说明 */
     documentation: string;
+    showWarning: boolean;
+    warningMessage: string;
+    showLabel: boolean;
     /**
      * 构造函数
      * @param id 节点数据的唯一标识符
@@ -24,4 +29,6 @@ export default abstract class NodeData {
      * @returns XML字符串
      */
     toXml(): string;
+    getIcon(): string;
+    setIcon(icon: string): void;
 }

package/dist/rfl/data/RuleFile.d.ts

@@ -6,6 +6,7 @@ export declare const ICON_JUECEBIAO_ICON = "udmp web-table";
 export declare const ICON_START_ICON = "udmp web-start";
 export declare const ICON_STOP_ICON = "udmp web-end";
 export declare const ICON_FILE_ICON = "udmp web-file";
+export declare const ICON_SCORECARD = "udmp web-scorecard";
 /**
  * 规则文件类型枚举
  */
@@ -17,7 +18,9 @@ export declare enum RULE_FILE_TYPE {
     /** 决策表文件 */
     DecisionTable = "DecisionTable",
     /** 决策树文件 */
-    DecisionTree = "DecisionTree"
+    DecisionTree = "DecisionTree",
+    /** 评分卡文件 */
+    Scorecard = "Scorecard"
 }
 /**
  * 文件信息类

package/dist/rfl/data/RuleNodeData.d.ts

@@ -54,6 +54,7 @@ export default class RuleNodeData extends TaskNodeData {
     selectDynamic: boolean;
     /** 绑定文件列表 */
     bindingFiles: BindingFile[];
+    constructor(id: string);
     /**
      * 转换为XML格式
      * @returns XML字符串

package/dist/rfl/data/SubflowNodeData.d.ts

@@ -15,6 +15,7 @@ export default class SubflowNodeData extends TaskNodeData {
     initialActions: TaskAction;
     /** 最终动作配置 */
     finalActions: TaskAction;
+    constructor(name: string);
     /**
      * 设置初始动作配置
      * @param language 动作语言

package/dist/rfl/data/TaskNodeData.d.ts

@@ -5,6 +5,11 @@ import { default as NodeData } from './NodeData';
  * 定义任务节点数据的基本属性和方法
  */
 export default abstract class TaskNodeData extends NodeData {
+    /**
+     * 构造函数
+     * @param id 节点数据的唯一标识符
+     */
+    constructor(id: string);
     /**
      * 获取任务节点类型
      * @returns 任务节点类型枚举值

package/dist/rfl/definition/ProcessDef.d.ts

@@ -1,5 +1,6 @@
 import { default as ProcessNodeDef } from './ProcessNodeDef';
 import { default as FlowProperties } from '../FlowProperties';
+import { NodeName, TaskNodeType } from './node/NodeType';
 import { FileInfo } from '../data/RuleFile';
 /**
  * 流程定义类
@@ -30,6 +31,10 @@ export default class ProcessDef {
      * 是否为主流程任务
      */
     private mainFlowTask;
+    /**
+     * 是否只读
+     */
+    private readOnly;
     /**
      * 节点映射表，用于存储所有流程节点
      */
@@ -38,6 +43,10 @@ export default class ProcessDef {
      * 是否启用暗黑模式
      */
     private darkMode;
+    /**
+     * 线条类型
+     */
+    private lineType;
     /**
      * 文件信息数组
      */
@@ -54,6 +63,8 @@ export default class ProcessDef {
      * 流程属性
      */
     private properties;
+    /** 连接ID计数器 */
+    private connectionId;
     /**
      * 添加起始节点
      * @returns 起始节点实例
@@ -75,6 +86,16 @@ export default class ProcessDef {
      * @param name 流程名称
      */
     setName(name: string): void;
+    /**
+     * 获取线条类型
+     * @returns 线条类型
+     */
+    getLineType(): string;
+    /**
+     * 设置线条类型
+     * @param lineType 线条类型
+     */
+    setLineType(lineType: string): void;
     /**
      * 判断是否为主流程任务
      * @returns 布尔值，true表示为主流程任务
@@ -90,6 +111,8 @@ export default class ProcessDef {
      * @param darkMode 是否启用暗黑模式
      */
     setDarkMode(darkMode: boolean): void;
+    getReadonlyMode(): boolean;
+    setReadOnly(readOnly: boolean): void;
     /**
      * 获取节点映射表
      * @returns 节点映射表
@@ -152,6 +175,16 @@ export default class ProcessDef {
      * @param tags 标签字符串
      */
     setTags(tags: string): void;
+    /**
+     * 获取连接ID
+     * @returns 连接ID
+     */
+    getConnectionId(): number;
+    /**
+     * 设置连接ID
+     * @param connectionId 连接ID
+     */
+    setConnectionId(connectionId: number): void;
     /**
      * 获取快速测试数据
      * @returns 快速测试数据字符串
@@ -167,22 +200,35 @@ export default class ProcessDef {
      * @returns 流程属性对象
      */
     getProperties(): FlowProperties;
+    createProcessNode(nodeNameType: NodeName, nodeId: string, nodeName: string, taskNodeType: TaskNodeType | null, taskId: string, positionX: number, positionY: number, startNode: ProcessNodeDef, endNode: ProcessNodeDef | null): ProcessNodeDef;
+    insertProcessNode(nodeNameType: NodeName, nodeId: string, nodeName: string, taskNodeType: TaskNodeType | null, taskId: string, positionX: number, positionY: number, startNode: ProcessNodeDef, endNode: ProcessNodeDef): ProcessNodeDef;
+    /**
+ * 根据节点类型创建对应的流程节点定义实例
+ * @param {NodeName} nodeNameType - 节点类型名称，用于区分分支、汇合、任务等节点
+ * @param {string} nodeId - 节点唯一标识
+ * @param {string} nodeName - 节点显示名称，为空时回退使用 taskId
+ * @param {TaskNodeType} taskNodeType - 任务节点子类型名称，用于区分动作任务、规则任务等
+ * @param {string} taskId - 关联的任务标识
+ * @returns {ProcessNodeDef | undefined} 对应类型的流程节点定义实例，未匹配的节点类型返回 undefined
+ */
+    private doCreateProcessNode;
     /**
-     * 创建流程节点
-     * @param nodeType 节点类型
+     * 移除节点
      * @param nodeId 节点ID
-     * @param nodeName 节点名称
-     * @param taskId 任务ID
-     * @param taskNodeName 任务节点名称
-     * @returns 创建的流程节点实例
      */
-    createProcessNode(nodeType: string, nodeId: string, nodeName: string, taskId: string, taskNodeName: string): ProcessNodeDef | undefined;
+    removeNode(nodeId: string): void;
+    /**
+     * 移除连接
+     * @param connectionId 连接ID
+     */
+    removeConnection(connectionId: string): void;
     /**
      * 从JSON数据初始化流程
      * @param root JSON根节点
      * @param importType 导入类型
      */
     initFromJson(root: any, importType: string): void;
+    validate(): void;
     /**
      * 从iLog格式JSON数据初始化流程
      * iLog格式: root 是 <RuleFlow> 的内容，直接包含 uuid/locale/NodeList/Properties