export default _sfc_main;
declare namespace _sfc_main {
    namespace props {
        namespace resourceId {
            export const type: StringConstructor;
            const _default: string;
            export { _default as default };
        }
        namespace resourceYear {
            const type_1: StringConstructor;
            export { type_1 as type };
            const _default_1: string;
            export { _default_1 as default };
        }
    }
    function setup(__props: any, { expose: __expose }: {
        expose: any;
    }): {
        props: any;
        dataList: import("vue").Ref<any, any>;
        defaultProps: import("vue").Ref<{
            children: string;
            label: string;
            isLeaf: string;
        }, {
            children: string;
            label: string;
            isLeaf: string;
        } | {
            children: string;
            label: string;
            isLeaf: string;
        }>;
        treeData: import("vue").Ref<never[], never[]>;
        graph: import("vue").Ref<any, any>;
        stencil: import("vue").Ref<any, any>;
        nowRouter: import("vue").Ref<string, string>;
        procData: import("vue").Ref<{}, {}>;
        opinionDailogRef: import("vue").Ref<any, any>;
        processId: import("vue").Ref<string, string>;
        treeRef: import("vue").Ref<any, any>;
        getProcessTraceTreeApi: () => Promise<void>;
        getProcessTraceDetailApi: () => Promise<void>;
        getProcessDiagramApi: () => Promise<void>;
        handleNodeClick: (data: any, node: any, component: any) => void;
        initData: () => void;
        loadStencil: () => void;
        initStencil: () => void;
        initGraph: () => void;
        openOpinionDialog: () => void;
        onMounted: (hook: any, target?: import("vue").ComponentInternalInstance | null | undefined) => void;
        ref: typeof ref;
        nextTick: typeof nextTick;
        readonly Graph: typeof Graph;
        readonly Shape: typeof Shape;
        readonly Addon: typeof Addon;
        readonly Node: typeof Node;
        readonly Edge: typeof Edge;
        readonly registAttrs: {
            grid: boolean;
            panning: boolean;
            mousewheel: {
                enabled: boolean;
                zoomAtMousePosition: boolean;
                modifiers: string;
                minScale: number;
                maxScale: number;
            };
            routers: {
                defaultRouter: {
                    name: string;
                };
                selfLoopRouter: {
                    name: string;
                    args: {
                        padding: number;
                    };
                };
                guaixianRouter: {
                    name: string;
                };
                zhengguanxiRouter: {
                    name: string;
                    args: {
                        offset: string;
                    };
                };
                xieguanxiRouter: {
                    name: string;
                    args: {
                        offset: number;
                    };
                };
                zhinengRouter: {
                    name: string;
                    args: {
                        startDirections: string[];
                        endDirections: string[];
                    };
                };
                ditieRouter: {
                    name: string;
                    args: {
                        startDirections: string[];
                        endDirections: string[];
                    };
                };
                rightSdieRouter: {
                    name: string;
                    args: {
                        side: string;
                        padding: number;
                    };
                };
                leftSideRouter: {
                    name: string;
                    args: {
                        side: string;
                        padding: number;
                    };
                };
            };
            connector: {
                name: string;
                args: {
                    radius: number;
                };
            };
            anchor: string;
            allowBlank: boolean;
            allowLoop: boolean;
            highlighting: {
                magnetAdsorbed: {
                    name: string;
                    args: {
                        attrs: {
                            fill: string;
                            stroke: string;
                        };
                    };
                };
            };
            resizing: boolean;
            rotating: boolean;
            selecting: {
                enabled: boolean;
                showNodeSelectionBox: boolean;
                showEdgeSelectionBox: boolean;
            };
            snapline: boolean;
            keyboard: boolean;
            clipboard: boolean;
            history: boolean;
            curNodeAttrs: {
                body: {
                    strokeWidth: number;
                    stroke: string;
                    fill: string;
                };
                text: {
                    fontSize: number;
                    fill: string;
                };
            };
            addedNodeAttrs: {
                body: {
                    strokeWidth: number;
                    fill: string;
                };
                text: {
                    fontSize: number;
                    fill: string;
                };
            };
            nodeSelectedAttrs: {
                body: {
                    strokeWidth: number;
                    stroke: string;
                };
            };
            norNodeBody: {
                body: {
                    strokeWidth: number;
                    stroke: string;
                    fill: string;
                };
            };
            edge: {
                attrs: {
                    line: {
                        stroke: string;
                        strokeWidth: number;
                        strokeDasharray: number;
                        targetMarker: {
                            name: string;
                            width: number;
                            height: number;
                        };
                    };
                };
                zIndex: number;
                vertices: never[];
                tools: {
                    name: string;
                    addable: boolean;
                    args: {
                        attrs: {
                            fill: string;
                        };
                    };
                };
            };
            edgeAttrs: {
                selected: {
                    line: {
                        strokeWidth: number;
                        stroke: string;
                        strokeDasharray: number;
                        targetMarker: {
                            name: string;
                            width: number;
                            height: number;
                        };
                    };
                };
                connected: {
                    line: {
                        strokeWidth: number;
                        stroke: string;
                        strokeDasharray: number;
                        targetMarker: {
                            name: string;
                            width: number;
                            height: number;
                        };
                    };
                };
                strokeSelected: {
                    line: {
                        strokeWidth: number;
                        stroke: string;
                        strokeDasharray: number;
                        targetMarker: {
                            name: string;
                            width: number;
                            height: number;
                        };
                    };
                };
                strokeUnselected: {
                    line: {
                        strokeWidth: number;
                        stroke: string;
                        strokeDasharray: number;
                        targetMarker: {
                            name: string;
                            width: number;
                            height: number;
                        };
                    };
                };
            };
            tools: {
                name: string;
                args: {
                    attrs: {
                        fill: string;
                        width: number;
                        height: number;
                        x: number;
                        y: number;
                        rx: number;
                        ry: number;
                        stroke: string;
                        'stroke-width': number;
                    };
                    addable: boolean;
                    removable: boolean;
                };
            };
            tools2: {
                name: string;
                args: {
                    addable: boolean;
                    removable: boolean;
                    removeRedundancies: boolean;
                    attrs: {
                        fill: string;
                    };
                };
            };
            ports: {
                groups: {
                    top: {
                        attrs: {
                            circle: {
                                r: number;
                                magnet: boolean;
                                stroke: string;
                                strokeWidth: number;
                                fill: string;
                                style: {
                                    visibility: string;
                                };
                            };
                        };
                        position: {
                            name: string;
                        };
                    };
                };
                items: {
                    group: string;
                    id: string;
                    args: {
                        x: string;
                        y: string;
                    };
                    attrs: {
                        circle: {
                            r: number;
                            magnet: boolean;
                            stroke: string;
                            strokeWidth: number;
                            fill: string;
                            style: {
                                visibility: string;
                            };
                        };
                    };
                }[];
            };
            stencil: {
                rect: {
                    inherit: string;
                    width: number;
                    height: number;
                    attrs: {
                        body: {
                            strokeWidth: number;
                            stroke: string;
                            fill: string;
                        };
                        text: {
                            fill: string;
                        };
                    };
                };
                text: {
                    inherit: string;
                    width: number;
                    height: number;
                    attrs: {
                        body: {
                            rx: number;
                            ry: number;
                            fill: string;
                            stroke: string;
                        };
                    };
                };
                textdark: {
                    inherit: string;
                    width: number;
                    height: number;
                    attrs: {
                        body: {
                            rx: number;
                            ry: number;
                            fill: string;
                            stroke: string;
                            'background-color': string;
                        };
                    };
                };
                polygon: {
                    inherit: string;
                    width: number;
                    height: number;
                    attrs: {
                        body: {
                            strokeWidth: number;
                            stroke: string;
                            fill: string;
                        };
                        text: {
                            fontSize: number;
                            fill: string;
                        };
                    };
                };
            };
            nodeBodyAttrs: {
                genTextAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                    text: {
                        fill: string;
                    };
                };
                genTextDarkAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                    text: {
                        fill: string;
                    };
                };
                startAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                };
                endAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                };
                selfEndAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                };
                polygonAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                };
                genNodeAttr: {
                    body: {
                        stroke: string;
                        fill: string;
                    };
                };
            };
        };
        readonly _nodeDef: typeof _nodeDef;
        readonly _edgeDef: typeof _edgeDef;
        readonly makeStartNode: typeof makeStartNode;
        readonly makeEndNode: typeof makeEndNode;
        readonly makeGenNode: typeof makeGenNode;
        opinionDailog: import("vue").DefineComponent<{}, {
            emit: (event: "refreshDataList", ...args: any[]) => void;
            visible: import("vue").Ref<boolean, boolean>;
            dataList: import("vue").Ref<{
                appendPersonName: string;
                opinionDateTime: string;
                content: string;
            }[], {
                appendPersonName: string;
                opinionDateTime: string;
                content: string;
            }[] | {
                appendPersonName: string;
                opinionDateTime: string;
                content: string;
            }[]>;
            init: (id?: number | undefined) => void;
            getData: (id: number) => void;
            handleCancel: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "refreshDataList"[], "refreshDataList", import("vue").PublicProps, Readonly<{}> & Readonly<{
            onRefreshDataList?: ((...args: any[]) => any) | undefined;
        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly getProcessTraceTree: any;
        readonly getProcessTraceDetail: any;
        readonly getProcessDiagram: any;
    };
}
import { ref } from "@vue/runtime-core";
import { nextTick } from "@vue/runtime-core";
import { Graph } from "@antv/x6/lib/graph/graph.js";
import { Shape } from "@antv/x6";
import { Addon } from "@antv/x6";
import { Node } from "@antv/x6/lib/model/node.js";
import { Edge } from "@antv/x6/lib/model/edge.js";
import { _nodeDef } from "../flow/config/fieldSetting.js";
import { _edgeDef } from "../flow/config/fieldSetting.js";
import { makeStartNode } from "../flow/config/fieldSetting.js";
import { makeEndNode } from "../flow/config/fieldSetting.js";
import { makeGenNode } from "../flow/config/fieldSetting.js";