sudoku/engine/types/Blueprint.d.ts

declare module BP {
    class BlueprintCreateUtil {
        static __init__(): Promise<void>;
        static reg(): void;
    }
    class BlueprintDecorator {
        static bpUserMap: Map<Function, TBPDeclaration>;
        static initDeclaration(name: string, cls: Function): TBPDeclaration;
        /**
         * 蓝图装饰器
         * @param options
         */
        static bpClass(target: any, options: BPDecoratorsOptionClass): TBPDeclaration;
        /**
         * 蓝图装饰器,属性
         */
        static bpProperty(target: any, propertyKey: string, options: BPDecoratorsOptionProp): void;
        /**
         * 蓝图装饰器，方法
         */
        static bpFunction(target: any, propertyKey: string, descriptor: any, options: BPDecoratorsOptionFunction): void;
        /**
         * 蓝图装饰器，getset
         */
        static bpAccessor(target: any, propertyKey: string, descriptor: any, options: BPDecoratorsOptionProp): void;
        /**
         * 增加一个蓝图枚举
         * @param name 枚举名称
         * @param merbers 枚举成员
         */
        static createBPEnum(name: string, merbers: TBPDeclarationMerber[]): void;
    }
    /**
     * 蓝图装饰器
     * @param options
     */
    function bpClass(options: BPDecoratorsOptionClass): (target: any) => void;
    /**
     * 蓝图装饰器,属性
     */
    function bpProperty(options: BPDecoratorsOptionProp): (target: any, propertyKey: string) => void;
    /**
     * 蓝图装饰器，方法
     */
    function bpFunction(options?: BPDecoratorsOptionFunction): (target: any, propertyKey: string, descriptor: any) => void;
    /**
     * 蓝图装饰器，getset
     */
    function bpAccessor(options: BPDecoratorsOptionProp): (target: any, propertyKey: string, descriptor: any) => void;
    /**
     * 增加一个蓝图枚举
     * @param name 枚举名称
     * @param merbers 枚举成员
     */
    function createBPEnum(name: string, merbers: TBPDeclarationMerber[]): void;
    class BlueprintLoader implements IResourceLoader {
        load(task: ILoadTask): Promise<BlueprintResource>;
        postLoad(task: ILoadTask, bp: BlueprintResource): Promise<void>;
    }
    class BlueprintResource extends Resource {
        data: IBPSaveData;
        dec: TBPDeclaration;
        allData: Record<string, any>;
        private _cls;
        private _bid;
        private varMap;
        private allNode;
        constructor(bid: string);
        get cls(): Function;
        private _initTarget;
        initClass(data: IBPSaveData): void;
        parse(): void;
        protected _disposeResource(): void;
    }
    class BlueprintConst {
        static MAX_CODELINE: number;
        static NULL_NODE: number;
        static VERSION: number;
        static EXT: string;
        static TYPE: string;
        static configPath: string;
    }
    const EXECID = "-1";
    const TARGETID = "-2";
    class BlueprintData {
        /**对当前打开的蓝图数据进行检测的逻辑 */
        getConstDataExt: (target: string, dataId: string) => IBPCNode;
        static allDataMap: Map<string, Record<string, IBPCNode>>;
        private static defFunOut;
        private static defFunIn;
        private static defTarget;
        private static defEventOut;
        /**所有的数据 */
        /**
         * constData里面的数据应该包含customData的数据
         */
        constData: Record<string, IBPConstNode>;
        /**自動生成的模板數據，這些數據不會在鼠標右鍵菜單中出現，也不會傳輸到ide層去 */
        autoCreateData: Record<string, IBPCNode>;
        private static readonly funlike;
        private static readonly checklike;
        private _extendsData;
        private _regFunction;
        private _getClass;
        static formatName(param: TBPDeclarationParam): string;
        static formatType(type: Laya.FPropertyType): Laya.FPropertyType;
        constructor(extendsData: Record<string, TBPDeclaration>, regFunction?: (fname: string, fun: Function, isMember: boolean, cls: any, target: string) => void, getClass?: (name: string) => any);
        get extendsData(): Record<string, TBPDeclaration>;
        getExtends(ext: string, arr?: string[]): string[];
        getConstDataById(target: string, dataId: string): IBPCNode;
        private _getConstData;
        /**在引擎执行的时候需要启用catch来提高效率，在ide中不需要，因为ide中有时候会经常变动数据 */
        isStartCatch: boolean;
        static clone<T>(obj: T): T;
        private _getConstByNode;
        getConstNode(node: IBPNode): IBPCNode;
        private _checkAndPush;
        private _createExtData;
        private _createConstData;
        isResetData: boolean;
        removeData(ext: string): void;
        resetData(data: TBPDeclaration, ext: string): void;
        initData(data: Record<string, TBPDeclaration>): void;
        private static handleCDataTypes;
        private static createCData;
        static formatData(data: IBPSaveData, assetId: string, dataMap?: Record<string, IBPCNode>, varMap?: Record<string, IBPVariable>): TBPDeclaration;
        private static _initTarget;
    }
    abstract class BlueprintNode<T extends BlueprintPin> {
        id: string;
        nid: number;
        name: string;
        type: BPType;
        def: IBPCNode;
        pins: T[];
        constructor();
        abstract createPin(def: TBPPinDef): T;
        addPin(pin: T): void;
        parse(def: IBPCNode): void;
        getPropertyItem(key: string): import("../datas/types/IBlueprint").IBPCInput;
        getValueType(key: string): "class" | "resource";
        isEmptyObj(o: any): boolean;
        /**
         * 强制写入target的inputValue
         * @param node
         * @returns
         */
        private _checkTarget;
        parseLinkData(node: IBPNode, manger: INodeManger<BlueprintNode<T>>): void;
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintNode<T>>): void;
        setFunction(fun: Function, isMember: boolean): void;
        setType(type: BPType): void;
        addInput(input: TBPPinDef[]): void;
        addOutput(output: TBPPinDef[]): void;
        getPinByName(id: string): T;
    }
    class BlueprintPin {
        private _direction;
        get direction(): EPinDirection;
        set direction(value: EPinDirection);
        id: string;
        name: string;
        nid: string;
        type: EPinType;
        otype: string;
        linkTo: BlueprintPin[];
        value: any;
        constructor();
        parse(def: TBPPinDef): void;
        startLinkTo(e: BlueprintPin): void;
    }
    class BlueprintUtil {
        static classMap: any;
        static bpData: BlueprintData;
        static onfinishCallbacks: Record<number, [
            Function,
            any,
            any[]
        ]>;
        static resouceMap: Map<string, any>;
        static CustomClassFinish: string;
        static customModify: boolean;
        static clone<T>(obj: T): T;
        static getConstNode(node?: IBPNode): IBPCNode;
        static getConstDataById(target: string, dataId: string): IBPCNode;
        /**
         * hook
         * @param name
         * @param data
         */
        static addCustomData(name: string, data: TBPDeclaration): void;
        static getDeclaration(name: string): TBPDeclaration;
        static initConstNode(): void;
        static getClass(ext: any): any;
        static regClass(name: string, cls: any): void;
        static regResByUUID(uuid: string, res: any): void;
        static getResByUUID(uuid: string): any;
        static getNameByUUID(uuid: string): string;
    }
    /**
     * 引脚方向
     */
    enum EPinDirection {
        Input = 0,
        Output = 1,
        All = 2
    }
    /**
     * 节点类型
     */
    enum EBlueNodeType {
        Unknow = "unkown",
        Event = "event",
        Fun = "fun",
        Pure = "pure",
        GetVariable = "var",
        SetVarialbe = "setVar",
        Branch = "branch",
        Sequnece = "sequnece"
    }
    /**
     * 引脚类型
     */
    enum EPinType {
        Exec = 0,
        BPFun = 1,
        Other = 2
    }
    interface IBluePrintSubclass {
        [BlueprintFactory.bpSymbol]: BlueprintRuntime;
        [BlueprintFactory.contextSymbol]: IRunAble;
        [key: string]: any;
    }
    interface IExcuteListInfo {
        nid: number;
    }
    interface INodeManger<T> {
        getNodeById(id: any): T;
        dataMap: Record<string, IBPCNode | IBPVariable>;
    }
    interface IOutParm {
        readonly name: string;
        setValue(runId: number, value: any): void;
    }
    interface IRuntimeDataManger {
        getDataById(nid: number): RuntimeNodeData;
        setPinData(pin: BlueprintPinRuntime, value: any, runId: number): void;
        getPinData(pin: BlueprintPinRuntime, runId: number): any;
        getRuntimePinById(id: string): RuntimePinData;
        getVar(name: string, runId: number): any;
        setVar(name: string, value: any, runId: number): void;
        clearVar(runId: number): void;
        saveContextData(from: number, to: number): void;
    }
    type TBPNodeDef = {
        name: string;
        id: string;
        type: BPType;
        inPut?: TBPPinDef[];
        outPut?: TBPPinDef[];
        fun?: Function;
    };
    type TBPPinDef = {
        id: string;
        name: string;
        type: string;
    };
    type TBPNodeData = {
        id: string;
        did: string;
        data: Record<string, TBPPinData>;
    };
    type TBPLinkInfo = {
        varname: string;
    };
    type TBPPinData = {
        value?: any;
        linkto?: string[];
    };
    const BlueprintDataList: IBPCNode[];
    /**
     * 开发者自定义相关
     */
    const customData: Record<string, TBPDeclaration>;
    const extendsData: Record<string, TBPDeclaration>;
    type TBPDecoratorsPropertType = "function" | "property" | "class";
    type TBPDecoratorsFuncType = "pure" | "function" | "event" | BPType.Pure | BPType.Function | BPType.Event;
    type TBPDeclarationType = "Enum" | "Node" | "Component" | "Others";
    /** 修饰符 */
    type BPModifiers = {
        /** 是否是私有 */
        isPrivate?: boolean;
        /** 是否是公有 */
        isPublic?: boolean;
        /** 是否是受保护的 */
        isProtected?: boolean;
        /** 是否是静态 */
        isStatic?: boolean;
        /** 是否为只读 */
        isReadonly?: boolean;
        /**
         * 是否是自动运行
         */
        isAutoRun?: boolean;
    };
    type TBPDeclaration = {
        /** 包名 */
        module?: string;
        /** 当前描述名 */
        name: string;
        /** 当前描述的具体类型 */
        type: TBPDeclarationType;
        /** 能否被继承 */
        canInherited?: boolean;
        /** 父类  */
        extends?: string;
        /** 事件相关 */
        events?: TBPDeclarationEvent[];
        /** 实现的接口名 */
        implements?: string[];
        /** 该描述的属性列表 */
        props?: TBPDeclarationProp[];
        /** 该描述的方法列表 */
        funcs?: TBPDeclarationFunction[];
        /** 构造函数 */
        construct?: TBPDeclarationConstructor;
        /** 枚举成员 */
        merbers?: TBPDeclarationMerber[];
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationMerber = {
        /** 枚举名称 */
        name: string;
        /** 枚举值 */
        value: number | string;
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationEvent = {
        name: string;
        params?: TBPDeclarationEventData[];
    };
    type TBPDeclarationEventData = {
        id?: number;
        /** 参数名称 */
        name: string;
        /** 参数类型 */
        type: string;
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationConstructor = {
        params?: TBPDeclarationParam[];
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationProp = {
        /** 变量名称 */
        name: string;
        value?: any;
        /** 变量类型 */
        type?: string | Function;
        customId?: string | number;
        /** 是否有getter 方法 */
        getter?: boolean;
        /** 是否有setter 方法 */
        setter?: boolean;
        /** 泛型 */
        typeParameters?: any;
        /** 修饰符 */
        modifiers?: BPModifiers;
        /** 是否来自父类 */
        fromParent?: string;
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationFunction = {
        /** 方法名称 */
        name: string;
        /**鼠标右键里面的菜单路径,如果填写none则代表不在菜单中显示 */
        menuPath?: string;
        /** 具体方法类型 */
        type?: TBPDecoratorsFuncType;
        /** 修饰符 */
        modifiers?: BPModifiers;
        /** 方法的参数列表 */
        params?: TBPDeclarationParam[];
        /** 方法的返回类型 */
        returnType: string | any[];
        /** 方法的返回注释 */
        returnTips?: string;
        /** 泛型 */
        typeParameters?: any;
        /** 注册的原始方法 */
        originFunc?: Function;
        /** 是否来自父类 */
        fromParent?: string;
        customId?: number | string;
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    type TBPDeclarationParam = {
        id?: number;
        /** 参数名称 */
        name: string;
        /** 参数类型 */
        type: string;
        /** 是否为可选项 */
        optional?: boolean;
        /** 是否为...方法 */
        dotdotdot?: boolean;
        /** 显示名称，没有默认使用name */
        caption?: string;
        /** 分组 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    };
    interface BPDecoratorsOptionBase {
        /** 标题，如果不提供将使用name */
        caption?: string;
        /** 注册对象成员类型 */
        propertType?: TBPDecoratorsPropertType;
        /** 修饰符 */
        modifiers?: BPModifiers;
        /** 分类 */
        catalog?: string;
        /** 提示内容 */
        tips?: string;
    }
    interface BPDecoratorsOptionClass extends BPDecoratorsOptionBase {
        /** 注册名称 */
        name: string;
        /** 继承的父类 */
        extends?: string;
        /** 能否被继承 */
        canInherited?: boolean;
        /** 构造函数参数 */
        construct?: TBPDeclarationConstructor;
        /** 事件相关 */
        events?: TBPDeclarationEvent[];
    }
    interface BPDecoratorsOptionFunction extends BPDecoratorsOptionBase {
        /** 方法或者构造函数参数，必填 */
        params?: TBPDeclarationParam[];
        /**
         * 方法分类
         * @default BPType.Function
         */
        type?: TBPDecoratorsFuncType;
        /**
         * 返回类型
         */
        returnType?: string;
    }
    interface BPDecoratorsOptionProp extends BPDecoratorsOptionBase {
        /** 参数类型 */
        type: string;
    }
    interface IBPSaveData {
        autoID: number;
        preload?: string[];
        extends: string;
        blueprintArr: Array<IBPStageData>;
        variable: IBPVariable[];
        functions: IBPStageData[];
        events: IBPCNode[];
        source?: any;
        globalInfo?: Record<string, any>;
    }
    interface CopyType {
        arr: (IBPNode | IBComment)[];
        width: number;
        height: number;
    }
    interface IBPVariable extends Partial<IBPCNode> {
        name: string;
        type: string;
        value?: any;
    }
    interface IBPStageData extends Partial<IBPCNode> {
        /** 修饰符 */
        modifiers?: BPModifiers;
        name: string;
        id: number;
        uiData?: {
            /**场景的x坐标位置 */
            x: number;
            /**场景的y坐标位置 */
            y: number;
            /**场景的缩放 */
            scale: number;
        };
        /**临时变量数据 */
        variable?: IBPVariable[];
        arr: Array<IBPNode>;
        comments?: Array<IBComment>;
        /**保存的时候不会有这个值，这是build的时候传值用的 */
        dataMap?: Record<string, IBPCNode>;
        tips?: string;
        properties?: Array<IBPCInput>;
        output?: IBPCOutput[];
    }
    interface IBComment {
        id: number;
        x: number;
        y: number;
        width: number;
        height: number;
        desc: string;
        fontSize?: number;
        color?: {
            r: number;
            g: number;
            b: number;
        };
        noSticky?: boolean;
    }
    interface IBPConstNode {
        extends?: string;
        data: Record<string, IBPCNode>;
        caption?: string;
    }
    interface IBPCNode {
        isSelf?: boolean;
        /**程序中用到的名字 */
        name: string;
        caption?: string;
        /** */
        bpType?: "function" | "event" | "prop" | "construct";
        target?: string;
        /**target有可能是uuid，所以需要这个别名 */
        targetAliasName?: string;
        /** 提示内容 */
        tips?: string;
        module?: string;
        /**如果是自定义函数会有这个id号 */
        customId?: number;
        /**泛型的类型定义 */
        typeParameters?: Record<string, {
            extends?: string[];
        }>;
        /** 修饰符 */
        modifiers?: BPModifiers;
        /** 数据唯一的id号,可以不写，默认为name*/
        id?: string | number;
        /** 旧的id号，用于兼容旧的版本 */
        oldId?: string;
        /**该节点的类型，如果是variable则类型为string */
        type: BPType | string;
        /**鼠标右键里面的菜单路径,如果填写none则代表不在菜单中显示 */
        menuPath?: string;
        /**版本号 */
        ver?: number;
        properties: Array<IBPCInput>;
        output?: IBPCOutput[];
        /**插槽上的默認值 */
        inputValue?: Record<string, any>;
        const?: boolean;
    }
    interface IBPCOutput {
        /**插槽的id号，一般用户自定义插槽会有这个值 */
        id?: string | number;
        /** 插槽名称 */
        name?: string;
        /**插槽的别名，通常用于自定义函数中 */
        caption?: string;
        tips?: string;
        /** 插槽允许的输出连接类型，输入字符串表示仅能连接该类型，数组表示可连接数组内类型*/
        type: Laya.FPropertyType;
    }
    interface IBPCInput {
        id?: string | number;
        type?: Laya.FPropertyType;
        name?: string;
        caption?: string;
        tips?: string;
        /**input简介提示，UI上显示使用，鼠标挪动到UI上会出现该提示信息 */
        alt?: string;
        /**inputValue的类型 */
        valueType?: "class" | "resource";
        isAsset?: boolean;
    }
    enum BPType {
        Event = "event",
        Function = "function",
        BPEvent = "bpEvent",
        Pure = "pure",
        Class = "class",
        Operator = "operator",
        GetValue = "getvalue",
        SetValue = "setvalue",
        GetTmpValue = "getTmpValue",
        SetTmpValue = "setTmpValue",
        Branch = "branch",
        Block = "Block",
        Sequence = "sequence",
        NewTarget = "newtarget",
        CustomFun = "customFun",
        CustomFunStart = "customFunStart",
        CustomFunReturn = "customFunReturn",
        Expression = "expression",
        Assertion = "Assertion"
    }
    interface IBPNode {
        /** 数据唯一的id号*/
        id: number;
        ver?: number;
        /**当前的类 */
        target?: string;
        name?: string;
        /** constData的id号 */
        cid: string;
        /**var或者event的id */
        dataId?: string;
        customId?: number;
        /**所有UI所用到的数据 */
        uiData?: {
            /**数据的x坐标位置 */
            x: number;
            /**数据的y坐标位置 */
            y: number;
            /**函数注释 */
            desc?: any;
            /**是否隐藏 */
            isHidden?: boolean;
            /**是否显示desc的气泡 */
            isShowDesc?: boolean;
        };
        debugType?: number;
        input?: Record<string, IBPInput>;
        /**对应inputValue的type关键字，如果typeKey发生变化说明inputValue需要被清空 */
        typeKey?: string;
        /**插槽上的默認值 */
        inputValue?: Record<string, any>;
        /**动态增加的input节点 */
        properties?: Array<IBPCInput>;
        /**动态增加的输出节点 */
        outputs?: IBPCOutput[];
        output?: Record<string, IBPOutput>;
        autoReg?: boolean;
    }
    interface IBPInput {
        type?: Laya.FPropertyType;
        /**插槽注释 */
        desc?: string;
        class?: string;
        resource?: string;
    }
    interface IBPOutput {
        infoArr: IBPConnType[];
    }
    interface IBPConnType {
        /** 插槽连接到的另一个节点的id */
        nodeId: number;
        /** 插槽连接到的另一个节点的第n个插槽 */
        index?: number;
        /**连接到的input或者output的ID号 */
        id?: string;
        /**连接到的input或者output的name */
        name?: string;
    }
    interface IBPProperty {
        title?: string;
        type: string;
        data: any;
    }
    class BPArray<T> {
        length: number;
        static getItem<T>(arr: Array<T>, index: number): T;
        static setItem<T>(arr: Array<T>, index: number, value: T): void;
        push(item: T): number;
        pop(): T;
        splice(start: number, deleteCount?: number): T;
        shift(): T;
        unshift(item: T): T;
        join(separator?: string): string;
        concat(item: ConcatArray<T>): T;
    }
    class BPMathLib {
        /**
         * 两数相加
         * @param a 第一个数
         * @param b 第二个数
         * @returns 两数相加的结果
         */
        static add(a: number, b: number): number;
        /**
         * 两数相减
         * @param a 被减数
         * @param b 减数
         * @returns 两数相减的结果
         */
        static subtract(a: number, b: number): number;
        /**
         * 两数相乘
         * @param a 第一个数
         * @param b 第二个数
         * @returns 两数相乘的结果
         */
        static multiply(a: number, b: number): number;
        /**
         * 两数相除
         * @param a 被除数
         * @param b 除数
         * @returns 两数相除的结果
         * @throws 如果除数为0，则抛出错误
         */
        static divide(a: number, b: number): number;
        /**
         * 计算数字的幂次方
         * @param base 底数
         * @param exponent 指数
         * @returns 幂次方的结果
         */
        static power(base: number, exponent: number): number;
        /**
         * 计算平方根
         * @param value 数字
         * @returns 平方根的结果
         * @throws 如果数字为负数，则抛出错误
         */
        static sqrt(value: number): number;
        /**
         * 计算一个数的绝对值
         * @param value 数字
         * @returns 数字的绝对值
         */
        static abs(value: number): number;
        /**
         * 计算正弦值
         * @param angle 角度
         * @returns 正弦值
         */
        static sin(angle: number): number;
        /**
         * 计算余弦值
         * @param angle 角度
         * @returns 余弦值
         */
        static cos(angle: number): number;
        /**
         * 计算正切值
         * @param angle 角度
         * @returns 正切值
         */
        static tan(angle: number): number;
        /**
         * 计算反正弦值
         * @param value 数值
         * @returns 反正弦值
         */
        static asin(value: number): number;
        /**
         * 计算反余弦值
         * @param value 数值
         * @returns 反余弦值
         */
        static acos(value: number): number;
        /**
         * 计算反正切值
         * @param value 数值
         * @returns 反正切值
         */
        static atan(value: number): number;
        /**
         * 计算 y/x（弧度表示）的反正切值
         * @param y y 轴坐标
         * @param x x 轴坐标
         * @returns 弧度
         */
        static atan2(y: number, x: number): number;
        /**
         * 计算两点之间的距离
         * @param x1 第一个点的x坐标
         * @param y1 第一个点的y坐标
         * @param x2 第二个点的x坐标
         * @param y2 第二个点的y坐标
         * @returns 两点之间的距离
         */
        static distance(x1: number, y1: number, x2: number, y2: number): number;
        /**
         * 四舍五入到指定的小数位数
         * @param value 要四舍五入的数字
         * @param decimals 小数位数，默认为0
         * @returns 四舍五入后的结果
         */
        static round(value: number, decimals?: number): number;
        /**
         * 向下取整
         * @param value 数字
         * @returns 向下取整后的结果
         */
        static floor(value: number): number;
        /**
         * 向上取整
         * @param value 数字
         * @returns 向上取整后的结果
         */
        static ceil(value: number): number;
        /**
         * 计算余数
         * @param dividend 被除数
         * @param divisor 除数
         * @returns 余数
         */
        static mod(dividend: number, divisor: number): number;
        /**
         * 计算两数的最小值
         * @param a 第一个数
         * @param b 第二个数
         * @returns 两数的最小值
         */
        static min(a: number, b: number): number;
        /**
         * 计算两数的最大值
         * @param a 第一个数
         * @param b 第二个数
         * @returns 两数的最大值
         */
        static max(a: number, b: number): number;
        /**
         * 生成随机数，介于 0（包含） 到 1（不包括）之间
         * @returns 随机数
         */
        static random(): number;
        /**
         * 判断a是否大于b
         * @param a 第一个数字
         * @param b 第二个数字
         * @returns 如果a大于b，则返回true；否则返回false
         */
        static greater(a: number, b: number): boolean;
        /**
         * 判断a是否小于b
         * @param a 第一个数字
         * @param b 第二个数字
         * @returns 如果a小于b，则返回true；否则返回false
         */
        static less(a: number, b: number): boolean;
        /**
         *
         * @param a
         * @param b
         * @returns 是否相同
         */
        static equal(a: any, b: any): any;
        /**
         * 判断a是否大于等于b
         * @param a 第一个数字
         * @param b 第二个数字
         * @returns 如果a大于等于b，则返回true；否则返回false
         */
        static greaterEqual(a: number, b: number): boolean;
        /**
         * 判断a是否小于等于b
         * @param a 第一个数字
         * @param b 第二个数字
         * @returns 如果a小于等于b，则返回true；否则返回false
         */
        static lessEqual(a: number, b: number): boolean;
    }
    class BPObject<T> {
        static getItem<T>(obj: Record<string, T>, key: string): T;
        static setItem<T>(obj: Record<string, T>, key: string, value: T): void;
    }
    class ExpressParse {
        _catch: Map<string, ExpressTree>;
        static brackets: string[];
        static brackmap: any;
        private static _instance;
        static get instance(): ExpressParse;
        private isOperator;
        private tokenize;
        parse(expression: string): ExpressTree;
    }
    class ExpressTree {
        value: any;
        left: ExpressTree | null;
        right: ExpressTree | null;
        static strReg: RegExp;
        static realMap: any;
        call(context: any): any;
        constructor(value: any);
        static autoFormat(value: string): any;
        equal(value: any, context: any): void;
        private static isNumber;
        private static isString;
        private static isExpress;
        private static splitExpress;
        clone(): ExpressTree;
        static operatorPriority: any;
        static _inited: boolean;
        static parseProperty(express: string): ExpressTree;
        static creatreExpressTree(express: string): ExpressTree;
        static init(): void;
    }
    class ExpressOrgin extends ExpressTree {
        constructor(value: any);
        call(context: any): any;
    }
    class ExpressString extends ExpressTree {
        constructor(value: any);
        call(context: any): any;
    }
    class ExpressProperty extends ExpressTree {
        constructor(value: any);
        propertys: string[];
        realObj: any;
        realKey: string;
        equal(value: any, context: any): any;
        call(context: any): any;
    }
    class ExpressFunction extends ExpressProperty {
        params: ExpressTree[];
        call(context: any): any;
    }
    class ExpressDict extends ExpressTree {
        call(context: any): any;
        equal(value: any, context: any): void;
    }
    const Precedence: any;
    class BlueprintExcuteNode extends BlueprintRunBase implements IRunAble {
        owner: any;
        varDefineMap: Map<string, boolean>;
        runtimeDataMgrMap: Map<string | symbol, RuntimeDataManger>;
        readCache: boolean;
        private _cacheMap;
        setCacheAble(node: BlueprintRuntimeBaseNode, runId: number, value: any): void;
        getCacheAble(node: BlueprintRuntimeBaseNode, runId: number): boolean;
        constructor(data: any);
        finish(runtime: IBPRutime): void;
        getDataMangerByID(id: string | symbol): IRuntimeDataManger;
        initData(key: string | symbol, nodeMap: Map<number, BlueprintRuntimeBaseNode>, localVarMap: Record<string, IBPVariable>, parentId?: string | symbol): void;
        debuggerPause: boolean;
        pushBack(excuteNode: IExcuteListInfo, callback: any): void;
        getSelf(): any;
        initVar(name: string, value: any): void;
        setVar(name: string, value: any): void;
        getVar(name: string): any;
        getCode(): string;
        beginExcute(runtimeNode: BlueprintRuntimeBaseNode, runner: IBPRutime, enableDebugPause: boolean, fromPin: BlueprintPinRuntime, parmsArray: any[], prePin: BlueprintPinRuntime): BlueprintPromise;
        endExcute(runtimeNode: BlueprintRuntimeBaseNode): void;
        parmFromCustom(parmsArray: any[], parm: any, parmname: string): void;
        vars: {
            [key: string]: any;
        };
        parmFromOtherPin(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, from: BlueprintPinRuntime, parmsArray: any[], runId: number): void;
        parmFromSelf(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runId: number): void;
        parmFromOutPut(outPutParmPins: BlueprintPinRuntime[], runtimeDataMgr: IRuntimeDataManger, parmsArray: any[]): void;
        excuteFun(nativeFun: Function, returnResult: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, caller: any, parmsArray: any[], runId: number): any;
        reCall(index: number): void;
    }
    class RuntimeDataManger implements IRuntimeDataManger {
        id: symbol | string;
        isInit: boolean;
        /**
        * 节点数据区Map
        */
        nodeMap: Map<number, RuntimeNodeData>;
        /**
         * 引脚数据Map
         */
        pinMap: Map<string, RuntimePinData>;
        parmsArray: RuntimePinData[];
        localVarObj: any;
        localVarMap: Map<number, any>;
        constructor(id: symbol | string);
        saveContextData(from: number, to: number): void;
        private _initGetVarObj;
        clearVar(runId: number): void;
        getVar(name: string, runId: number): any;
        setVar(name: string, value: any, runId: number): void;
        getDataById(nid: number): RuntimeNodeData;
        getRuntimePinById(id: string): RuntimePinData;
        setPinData(pin: BlueprintPinRuntime, value: any, runId: number): void;
        getPinData(pin: BlueprintPinRuntime, runId: number): any;
        initData(nodeMap: Map<number, BlueprintRuntimeBaseNode>, localVarMap: Record<string, IBPVariable>): void;
    }
    class BlueprintGenCodeNode extends BlueprintRunBase implements IRunAble {
        finish(runtime: IBPRutime): void;
        setCacheAble(node: BlueprintRuntimeBaseNode, runId: number, value: any): void;
        getCacheAble(node: BlueprintRuntimeBaseNode, runId: number): boolean;
        getDataMangerByID(id: string | symbol): IRuntimeDataManger;
        initData(key: string | symbol, nodeMap: Map<number, BlueprintRuntimeBaseNode>): void;
        debuggerPause: boolean;
        readCache: boolean;
        pushBack(excuteNode: IExcuteListInfo): void;
        getSelf(): void;
        reCall(index: number): void;
        getVar(name: string): void;
        initVar(name: string, value: any): void;
        setVar(name: string, value: any): void;
        find(input: any, outExcutes: BlueprintPinRuntime[]): BlueprintPinRuntime;
        codes: string[][];
        currentFun: string[];
        vars: {
            [key: string]: any;
        };
        blockMap: Map<number, any>;
        beginExcute(runtimeNode: BlueprintRuntimeBaseNode): BlueprintPromise;
        endExcute(runtimeNode: BlueprintRuntimeBaseNode): void;
        parmFromOtherPin(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, from: BlueprintPinRuntime, parmsArray: any[], runId: number): void;
        parmFromSelf(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runId: number): void;
        parmFromOutPut(outPutParmPins: BlueprintPinRuntime[], runtimeDataMgr: IRuntimeDataManger, parmsArray: any[]): void;
        parmFromCustom(parmsArray: any[], parm: any, parmname: string): void;
        excuteFun(nativeFun: Function, returnResult: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, caller: any, parmsArray: any[], runId: number): void;
        toString(): string;
        getCode(): string;
    }
    class BlueprintRunBase {
        listNode: BlueprintRuntimeBaseNode[];
    }
    class RuntimeNodeData {
        map: Map<number, any[]>;
        callFunMap: Map<number, Function>;
        eventName: string;
        constructor();
        getCallFun(runId: number): Function;
        setCallFun(runId: number, fun: Function): void;
        getParamsArray(runId: number): any[];
    }
    class RuntimePinData implements IOutParm {
        name: string;
        private value;
        private valueMap;
        constructor();
        copyValue(runId: number, toRunId: number): void;
        initValue(value: any): void;
        setValue(runId: number, value: any): void;
        private getValueOnly;
        getValue(runId: number): any;
    }
    class BluePrintBlock implements INodeManger<BlueprintRuntimeBaseNode>, IBPRutime {
        hasRefAnony: boolean;
        localVarMap: Record<string, IBPVariable>;
        get blockSourceType(): EBlockSource;
        private poolIds;
        protected _maxID: number;
        /**
         * block ID 注释
         */
        id: symbol | string;
        /**
         * block 名称
         */
        name: string;
        /**
         * 节点Map
         */
        nodeMap: Map<any, BlueprintRuntimeBaseNode>;
        /**
         * 执行list
         */
        excuteList: BlueprintRuntimeBaseNode[];
        anonymousfunMap: Map<number, BlueprintEventNode>;
        anonymousBlockMap: Map<string, BluePrintEventBlock>;
        dataMap: Record<string, IBPVariable | IBPCNode>;
        constructor(id: symbol | string);
        getDataMangerByID(context: IRunAble): IRuntimeDataManger;
        get bpId(): string;
        getNodeById(id: any): BlueprintRuntimeBaseNode;
        idToIndex: Map<number, number>;
        private _addNode;
        optimizeByStart(value: BlueprintRuntimeBaseNode, excuteAbleList: BlueprintRuntimeBaseNode[]): void;
        clear(): void;
        optimize(): void;
        protected onParse(bpjson: IBPNode[]): void;
        append(node: BlueprintRuntimeBaseNode, item: IBPNode): void;
        getRunID(): number;
        _recoverRunID(id: number, runtimeDataMgr: IRuntimeDataManger): void;
        recoverRunID(id: number, runtimeDataMgr: IRuntimeDataManger): void;
        runAnonymous(context: IRunAble, event: BlueprintEventNode, parms: any[], cb: Function, runId: number, execId: number, newRunId: number, oldRuntimeDataMgr: IRuntimeDataManger): boolean;
        runByContext(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, node: IExcuteListInfo, enableDebugPause: boolean, cb: Function, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime, notRecover?: boolean): boolean;
        finish(context: IRunAble): void;
    }
    enum EBlockSource {
        Unknown = 0,
        Main = 1,
        Function = 2
    }
    class BluePrintComplexBlock extends BluePrintBlock {
        static EventId: number;
        private _asList;
        private _pendingClass;
        private _eventId;
        constructor(id: symbol | string);
        protected initEventBlockMap(map: Map<number, BlueprintEventNode>, eventMap: Map<string, BluePrintEventBlock>): void;
        optimize(): void;
        parse(bpjson: Array<IBPNode>, getCNodeByNode: (node: IBPNode) => IBPCNode, varMap: Record<string, IBPVariable>): void;
        private _onReParse;
        protected onEventParse(eventName: string): void;
        private _checkReady;
        append(node: BlueprintRuntimeBaseNode, item: IBPNode): void;
        finishChild(context: IRunAble, runtime: IBPRutime): void;
    }
    class BluePrintEventBlock extends BluePrintBlock {
        protected parentId: symbol | string;
        protected parent: BluePrintComplexBlock;
        haRef: boolean;
        static findParamPin(node: BlueprintRuntimeBaseNode, nodeMap: Map<any, BlueprintRuntimeBaseNode>, anonymousfunMap: Map<number, BlueprintEventNode>, excuteList: BlueprintRuntimeBaseNode[], bluePrintEventBlock: BluePrintEventBlock): void;
        init(event: BlueprintEventNode): void;
        private _checkRef;
        optimizeByBlockMap(parent: BluePrintComplexBlock): void;
        getRunID(): number;
        recoverRunID(id: number, runtimeDataMgr: IRuntimeDataManger): void;
        run(context: IRunAble, event: BlueprintEventNode, parms: any[], cb: Function, runId: number, execId: number): boolean;
        getDataMangerByID(context: IRunAble): IRuntimeDataManger;
        get bpId(): string;
        get blockSourceType(): EBlockSource;
        finish(context: IRunAble): void;
    }
    class BluePrintFunBlock extends BluePrintComplexBlock {
        mainBlock: BluePrintMainBlock;
        funStart: BlueprintCustomFunStart;
        isStatic: boolean;
        funBlock: BluePrintFunStartBlock;
        get bpId(): string;
        get blockSourceType(): EBlockSource;
        optimize(): void;
        protected onParse(bpjson: IBPNode[]): void;
        parse(bpjson: IBPNode[], getCNodeByNode: (node: IBPNode) => IBPCNode, varMap: Record<string, IBPVariable>): void;
        run(context: IRunAble, eventName: string, parms: any[], cb: Function, runId: number, execId: number, outExcutes: BlueprintPinRuntime[], runner: IBPRutime, oldRuntimeDataMgr: IRuntimeDataManger): boolean;
    }
    class BluePrintFunStartBlock extends BluePrintEventBlock {
        funEnds: BlueprintCustomFunReturn[];
        funStart: BlueprintCustomFunStart;
        init(event: BlueprintCustomFunStart): void;
        runFun(context: IRunAble, eventName: string, parms: any[], cb: Function, runId: number, execId: number, outExcutes: BlueprintPinRuntime[], runner: IBPRutime, oldRuntimeDataMgr: IRuntimeDataManger): boolean;
    }
    class BluePrintMainBlock extends BluePrintComplexBlock {
        autoAnonymousfuns: BlueprintEventNode[];
        autoRunNodes: BlueprintAutoRun[];
        eventBlockMap: Map<string, BluePrintEventBlock>;
        constructor(id: symbol);
        get bpName(): string;
        get blockSourceType(): EBlockSource;
        eventMap: Map<any, BlueprintEventNode>;
        cls: Function;
        optimize(): void;
        protected onEventParse(eventName: string): void;
        protected _onEventParse(...args: any[]): void;
        append(node: BlueprintRuntimeBaseNode, item: IBPNode): void;
        runAuto(context: IRunAble): void;
        run(context: IRunAble, event: BlueprintEventNode, parms: any[], cb: Function, runId: number, execId: number): boolean;
        finishChild(context: IRunAble, runtime: IBPRutime): void;
    }
    class BlueprintFactory {
        static readonly bpSymbol: unique symbol;
        static readonly contextSymbol: unique symbol;
        static readonly onChangeSymbol: unique symbol;
        static readonly autoRunSymbol: unique symbol;
        private static _funMap;
        private static _instance;
        private static _bpMap;
        private static _bpContextMap;
        static bpNewMap: Map<string, IBPCNode>;
        static BPExcuteCls: any;
        static BPRuntimeCls: any;
        /**
         * 根据节点类型创建相应的对象
         * @param type
         * @param cls
         */
        static regBPClass(type: BPType, cls: new () => BlueprintRuntimeBaseNode): void;
        static regFunction(fname: string, fun: Function, isMember?: boolean, cls?: any, target?: string): void;
        static getFunction(fname: string, target: string): [
            Function,
            boolean
        ];
        static regBPContextData(type: BPType, cls: new () => RuntimeNodeData): void;
        static getBPContextData(type: BPType): new () => RuntimeNodeData;
        /**
         * 生成类
         * @param name
         * @param cls
         * @returns
         */
        static createCls<T>(name: string, cls: T): T;
        /**
         * 解析数组
         * @param name
         * @param isPlaying
         * @param newClass
         * @param data
         * @param funs
         * @param varMap
         */
        static parseCls(name: string, saveData: IBPSaveData, newClass: any, data: IBPStageData, funs: IBPStageData[], varMap: Record<string, IBPVariable>, preload: string[]): void;
        static createClsNew<T>(name: string, saveData: IBPSaveData, cls: T, data: IBPStageData, funs: IBPStageData[], varMap: Record<string, IBPVariable>): T;
        static initClassHook(parent: string, cls: Function): void;
        static onPropertyChanged_EM(bp: any): void;
        static get instance(): BlueprintFactory;
        createNew(config: IBPCNode, item: IBPNode): BlueprintRuntimeBaseNode;
    }
    class BlueprintPinRuntime extends BlueprintPin {
        /**
         * 所属节点
        */
        owner: BlueprintRuntimeBaseNode;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, runner: IBPRutime, runId: number, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise | number;
        excute(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, runner: IBPRutime, runId: number): BlueprintPinRuntime;
        getValueCode(): any;
    }
    class BlueprintPromise implements IExcuteListInfo {
        nid: number;
        enableDebugPause: boolean;
        pin: BlueprintPinRuntime;
        prePin: BlueprintPinRuntime;
        static create(): BlueprintPromise;
        private _completed;
        private _callback;
        /**
        * 等待行为完成回调
        * @param callback 完成回调接口
        */
        wait(callback: (mis: BlueprintPromise) => void): void;
        hasCallBack(): boolean;
        complete(): void;
        recover(): void;
        clear(): void;
    }
    class BlueprintRuntime {
        isRunningInIDE: boolean;
        mainBlock: BluePrintMainBlock;
        funBlockMap: Map<string, BluePrintFunBlock>;
        varMap: Record<string, IBPVariable>;
        dataMap: Record<string, IBPVariable | IBPCNode>;
        constructor();
        run(context: IRunAble, event: BlueprintEventNode, parms: any[], cb: Function): void;
        /**
         * 执行自定义函数
         * @param context
         * @param funName
         * @param parms
         */
        runCustomFun(context: IRunAble, funId: string, parms: any[], cb: Function, runId: number, execId: number, outExcutes: BlueprintPinRuntime[], runner: IBPRutime, oldRuntimeDataMgr: IRuntimeDataManger): boolean;
        parse(mainBlockData: IBPStageData, getCNodeByNode: (node: IBPNode) => IBPCNode, varMap: Record<string, IBPVariable>, newCls: Function): void;
        parseFunction(funData: IBPStageData, getCNodeByNode: (node: IBPNode) => IBPCNode): void;
        toCode(context: IRunAble): void;
    }
    /**
     *
     */
    class BlueprintStaticFun {
        /**
         * @private
         * @param outExcutes
         * @param input
         * @returns
         */
        static switchFun(outExcutes: BlueprintPinRuntime[], input: any): BlueprintPinRuntime;
        /**
         * 打印
         * @param str
         */
        static print(str: string): void;
        static getTempVar(name: string, runtimeDataMgr: IRuntimeDataManger, runId: number): any;
        static setTempVar(value: any, name: string, runtimeDataMgr: IRuntimeDataManger, runId: number): void;
        /**
         * @private
         * @param target
         * @param name
         * @param context
         * @returns
         */
        static getVariable(target: IBluePrintSubclass, name: string, context: IRunAble): any;
        /**
        * @private
        * @param target
        * @param name
        * @param context
        * @returns
        */
        static getSelf(name: string, context: IRunAble): any;
        /**
         * @private
         * @param target
         * @param value
         * @param name
         * @param context
         */
        static setVariable(target: IBluePrintSubclass, value: any, name: string, context: IRunAble): any;
        /**
         * 等待
         * @param second
         * @returns
         */
        static waitTime(second: number): Promise<boolean>;
        /**
         * @private
         * @returns
         */
        static expression(): boolean;
        /**
         * @private
         * @param target
         * @param value
         * @param name
         * @param context
         */
        static typeInstanceof<T>(outExcutes: BlueprintPinRuntime[], target: any, type: new () => T): BlueprintPinRuntime;
        /**
         * @private
         * @param nextExec
         * @param outPutParmPins
         * @param parms
         * @param context
         * @param runner
         * @param runtimeDataMgr
         */
        private static runBranch;
        /**
         * @private
         * @param target
         * @param value
         * @param name
         * @param context
         */
        static forEach(inputExcute: BlueprintPinRuntime, inputExcutes: BlueprintPinRuntime[], outExcutes: BlueprintPinRuntime[], outPutParmPins: BlueprintPinRuntime[], context: IRunAble, runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger, runId: number, array: any[]): BlueprintPinRuntime;
        /**
        * @private
        * @param target
        * @param value
        * @param name
        * @param context
        */
        static forEachWithBreak(inputExcute: BlueprintPinRuntime, inputExcutes: BlueprintPinRuntime[], outExcutes: BlueprintPinRuntime[], outPutParmPins: BlueprintPinRuntime[], context: IRunAble, runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger, runId: number, array: any[]): BlueprintPinRuntime;
        /**
         * @private
         * @param target
         * @param value
         * @param name
         * @param context
         */
        static forLoop(inputExcute: BlueprintPinRuntime, inputExcutes: BlueprintPinRuntime[], outExcutes: BlueprintPinRuntime[], outPutParmPins: BlueprintPinRuntime[], context: IRunAble, runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger, runId: number, firstIndex: number, lastIndex: number, step?: number): BlueprintPinRuntime;
        /**
        * @private
        * breakNode 1 代表只在执行中，2代表执行中断，0代表执行完毕
        */
        static forLoopWithBreak(inputExcute: BlueprintPinRuntime, inputExcutes: BlueprintPinRuntime[], outExcutes: BlueprintPinRuntime[], outPutParmPins: BlueprintPinRuntime[], context: IRunAble, runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger, runId: number, firstIndex: number, lastIndex: number, step?: number): BlueprintPinRuntime;
        /**
         * 执行表达式
         * @param express
         * @param a
         * @param b
         * @param c
         * @returns
         */
        static runExpress(express: string, a: any, b: any, c: any): any;
    }
    interface IBPRutime {
        readonly name: string;
        readonly blockSourceType: EBlockSource;
        readonly bpId: string;
        getDataMangerByID(context: IRunAble): IRuntimeDataManger;
        getRunID(): number;
        runAnonymous(context: IRunAble, event: BlueprintEventNode, parms: any[], cb: Function, runId: number, execId: number, newRunId: number, oldRuntimeDataMgr: IRuntimeDataManger): boolean;
        runByContext(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, node: IExcuteListInfo, enableDebugPause: boolean, cb: Function, runid: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime, notRecover?: boolean): boolean;
    }
    interface IRunAble {
        debuggerPause: boolean;
        readCache: boolean;
        pushBack(excuteNode: IExcuteListInfo, callback: any): void;
        readonly vars: {
            [key: string]: any;
        };
        beginExcute(runtimeNode: BlueprintRuntimeBaseNode, runner: IBPRutime, enableDebugPause: boolean, fromPin: BlueprintPinRuntime, parmsArray: any[], prePin: BlueprintPinRuntime): BlueprintPromise;
        endExcute(runtimeNode: BlueprintRuntimeBaseNode): void;
        parmFromOtherPin(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, from: BlueprintPinRuntime, parmsArray: any[], runId: number): void;
        parmFromSelf(current: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runId: number): void;
        parmFromOutPut(outPutParmPins: BlueprintPinRuntime[], runtimeDataMgr: IRuntimeDataManger, parmsArray: any[]): void;
        parmFromCustom(parmsArray: any[], parm: any, parmname: string): void;
        excuteFun(nativeFun: Function, returnResult: BlueprintPinRuntime, runtimeDataMgr: IRuntimeDataManger, caller: any, parmsArray: any[], runId: number): any;
        getCode(): string;
        getVar(name: string): any;
        setVar(name: string, value: any): void;
        initVar(name: string, value: any): void;
        reCall(index: number): void;
        getSelf(): any;
        initData(key: string | symbol, nodeMap: Map<number, BlueprintRuntimeBaseNode>, localVarMap: Record<string, IBPVariable>, parentId?: string | symbol): void;
        getDataMangerByID(id: symbol | string): IRuntimeDataManger;
        setCacheAble(node: BlueprintRuntimeBaseNode, runId: number, value: any): void;
        getCacheAble(node: BlueprintRuntimeBaseNode, runId: number): boolean;
        finish(runtime: IBPRutime): void;
    }
    class BluePrintAsNode extends BlueprintRuntimeBaseNode {
        optimize(): void;
    }
    class BlueprintAutoRun extends BlueprintRuntimeBaseNode {
        protected colloctParam(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, inputPins: BlueprintPinRuntime[], runner: IBPRutime, runId: number, prePin: BlueprintPinRuntime): any[];
    }
    class BluePrintBlockNode extends BlueprintComplexNode {
        deal: (inputExcute: BlueprintPinRuntime, inputExcutes: BlueprintPinRuntime[], outExcutes: BlueprintPinRuntime[], outPutParmPins: BlueprintPinRuntime[], context: IRunAble, runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger, runId: number, ...args: any) => BlueprintPinRuntime;
        next(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime): BlueprintPinRuntime;
        setFunction(fun: Function): void;
    }
    class BlueprintComplexNode extends BlueprintRuntimeBaseNode {
        /**
         * 输入引脚
         */
        inExcutes: BlueprintPinRuntime[];
        constructor();
        next(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime): BlueprintPinRuntime;
        find: (outExcutes: BlueprintPinRuntime[], ...args: any) => BlueprintPinRuntime;
        addPin(pin: BlueprintPinRuntime): void;
        setFunction(fun: Function): void;
    }
    class BlueprintCustomFunNode extends BlueprintFunNode {
        /**
         * 输入引脚
         */
        inExcutes: BlueprintPinRuntime[];
        functionID: string;
        staticContext: IRunAble;
        bpruntime: BlueprintRuntime;
        private _isCheck;
        constructor();
        colloctParam(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, inputPins: BlueprintPinRuntime[], runner: IBPRutime, runId: number, prePin: BlueprintPinRuntime): any[];
        private _checkFun;
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintFunNode>): void;
        protected excuteFun(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, runner: IBPRutime, caller: IBluePrintSubclass, parmsArray: any[], runId: number, fromPin: BlueprintPinRuntime): Promise<any>;
        protected _excuteFun(context: IRunAble, cb: any, parmsArray: any[], runner: IBPRutime): void;
        addPin(pin: BlueprintPinRuntime): void;
        optimize(): void;
        setFunction(fun: Function, isMember: boolean): void;
        customFun(parms: any[]): void;
    }
    class BlueprintCustomFunReturn extends BlueprintRuntimeBaseNode {
        /**
         * 输入引脚
         */
        inExcutes: BlueprintPinRuntime[];
        constructor();
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise | number;
        initData(runtimeDataMgr: IRuntimeDataManger, curRunId: number, runId: number, parms: any[], offset: number, outExcutes: BlueprintPinRuntime[], runner: IBPRutime, oldRuntimeDataMgr: IRuntimeDataManger): void;
        addPin(pin: BlueprintPinRuntime): void;
    }
    class BlueprintCustomFunReturnContext extends RuntimeNodeData {
        returnMap: Map<number, IOutParm[]>;
        runIdMap: Map<number, number>;
        outExcutesMap: Map<number, BlueprintPinRuntime[]>;
        runnerMap: Map<number, [
            IBPRutime,
            IRuntimeDataManger
        ]>;
        constructor();
        initData(curRunId: number, runId: number, parms: any[], offset: number, outExcutes: BlueprintPinRuntime[], runner: IBPRutime, runtimeDataMgr: IRuntimeDataManger): void;
        runExcute(runId: number, index: number, context: IRunAble): void;
        returnResult(runId: number, curRunId: number): void;
    }
    class BlueprintCustomFunStart extends BlueprintEventNode {
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintEventNode>): void;
    }
    class BlueprintEventNode extends BlueprintRuntimeBaseNode {
        /**
         * 输出引脚
         */
        outExcute: BlueprintPinRuntime;
        eventName: string;
        autoReg: boolean;
        isAnonymous: boolean;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintEventNode>): void;
        setFunction(fun: Function, isMember: boolean): void;
        emptyExcute(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
        addPin(pin: BlueprintPinRuntime): void;
        optimize(): void;
        initData(runtimeDataMgr: IRuntimeDataManger, parms: any[], curRunId: number): void;
    }
    class BlueprintFunNode extends BlueprintRuntimeBaseNode {
        /**
         * 输入引脚
         */
        inExcute: BlueprintPinRuntime;
        /**
         * 输出引脚
         */
        outExcute: BlueprintPinRuntime;
        eventName: string;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintRuntimeBaseNode>): void;
        private excuteHookFun;
        protected excuteFun(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, runner: IBPRutime, caller: any, parmsArray: any[], runId: number, fromPin: BlueprintPinRuntime): any;
        next(): BlueprintPinRuntime;
        addPin(pin: BlueprintPinRuntime): void;
        optimize(): void;
    }
    class BlueprintGetTempVarNode extends BlueprintRuntimeBaseNode {
        protected _varKey: string;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintRuntimeBaseNode>): void;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
    }
    class BlueprintGetVarNode extends BlueprintRuntimeBaseNode {
        protected _varKey: string;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintRuntimeBaseNode>): void;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
    }
    class BlueprintNewTargetNode extends BlueprintRuntimeBaseNode {
        cls: ClassDecorator;
        parse(def: IBPCNode): void;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
    }
    class BlueprintRuntimeBaseNode extends BlueprintNode<BlueprintPinRuntime> implements IExcuteListInfo {
        private _refNumber;
        staticNext: BlueprintPinRuntime;
        private static _EMPTY;
        nativeFun: Function;
        isMember: boolean;
        funcode: string;
        canCache: boolean;
        /**
         * 输入参数列表
         */
        inPutParmPins: BlueprintPinRuntime[];
        /**
         * 输出参数列表
         */
        outPutParmPins: BlueprintPinRuntime[];
        returnValue: BlueprintPinRuntime;
        /**
         * 输出引脚
        */
        outExcutes: BlueprintPinRuntime[];
        tryExcute: (context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime) => BlueprintPinRuntime | BlueprintPromise | number;
        hasDebugger: boolean;
        constructor();
        addRef(): void;
        getRef(): number;
        emptyExcute(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
        createPin(def: TBPPinDef): BlueprintPinRuntime;
        protected excuteFun(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, runner: IBPRutime, caller: any, parmsArray: any[], runId: number, fromPin: BlueprintPinRuntime): any;
        protected colloctParam(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, inputPins: BlueprintPinRuntime[], runner: IBPRutime, runId: number, prePin: BlueprintPinRuntime): any[];
        private _checkRun;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise | number;
        next(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime): BlueprintPinRuntime;
        addPin(pin: BlueprintPinRuntime): void;
        optimize(): void;
        setFunction(fun: Function, isMember: boolean): void;
        protected addNextPIn(): void;
    }
    class BlueprintSequenceNode extends BlueprintComplexNode {
        next(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, parmsArray: any[], runner: IBPRutime, enableDebugPause: boolean, runId: number): BlueprintPinRuntime;
        setFunction(fun: Function): void;
    }
    class BlueprintSetTempVarNode extends BlueprintFunNode {
        protected _varKey: string;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintRuntimeBaseNode>): void;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
    }
    class BlueprintSetVarNode extends BlueprintFunNode {
        protected _varKey: string;
        constructor();
        protected onParseLinkData(node: IBPNode, manger: INodeManger<BlueprintRuntimeBaseNode>): void;
        step(context: IRunAble, runtimeDataMgr: IRuntimeDataManger, fromExcute: boolean, runner: IBPRutime, enableDebugPause: boolean, runId: number, fromPin: BlueprintPinRuntime, prePin: BlueprintPinRuntime): BlueprintPinRuntime | BlueprintPromise;
    }
    class TestBluePrint {
        static BPMap: Map<string, TBPNodeDef>;
        regBPNode(): void;
        testBPNode(): void;
        constructor();
    }
    class test {
        constructor();
    }
}