import { Vector } from './vector.js';
import { Node, NodeOptions, SerializedNode } from './node.js';
import { Hooks } from './hooks.js';
import { Group, SerializedGroup } from './group.js';
import { Connector, SerializedConnector } from './connector.js';
import { AVLTree } from '../utils/avl-tree.js';
import { Serializable, Rules, DataPersistenceProvider, DataFetchProvider, RuleColors, SerializedRuleColors, FlowRenderers } from '../common/interfaces.js';
import { SubFlowNode } from './subflow-node.js';
import { TunnelNode, SerializedTunnelNode } from './tunnel-node.js';
import { Graph } from './graph.js';
import { Terminal } from './terminal.js';
import { FlowConnect } from '../flow-connect.js';
export declare class Flow extends Hooks implements Serializable<SerializedFlow> {
    flowConnect: FlowConnect;
    name?: string;
    id?: string;
    rules?: Rules;
    ruleColors?: RuleColors;
    sortedNodes: AVLTree<Node>;
    nodes: Map<string, Node>;
    groups: Group[];
    connectors: Map<string, Connector>;
    floatingConnector?: Connector;
    inputs: TunnelNode[];
    outputs: TunnelNode[];
    get state(): FlowState;
    globalEvents: Hooks;
    parentFlow?: Flow;
    nodeHitColors: Map<string, Node>;
    groupHitColors: Map<string, Group>;
    listeners: Record<string, number>;
    executionGraph: Graph;
    readonly renderers: FlowRenderers;
    private constructor();
    static create(flowConnect: FlowConnect, options?: FlowOptions): Flow;
    transform(): void;
    existsInFlow(flow: Flow): boolean | undefined;
    addInput(name: string, dataType: string, position?: Vector): TunnelNode;
    addOutput(name: string, dataType: string, position: Vector): TunnelNode;
    private _addIO;
    addSubFlow(subFlow: Flow, position?: Vector): SubFlowNode | undefined;
    removeSubFlow(subFlow: Flow): void;
    removeSubFlow(subFlowNode: SubFlowNode): void;
    createNode<T extends Node = Node, O extends NodeOptions = NodeOptions>(type: string, position: Vector, options: O): T;
    private _createNode;
    private addNode;
    removeNode(nodeOrID: Node | string): void;
    removeConnector(id: string): void;
    removeAllFocus(): void;
    render(): void;
    start(): void;
    stop(): void;
    setFloatingConnector(floatingPos: Vector, fixedEnd: Terminal, type: string): void;
    removeFloatingConnector(): Terminal | undefined;
    private static deSerializeState;
    serialize(persist?: DataPersistenceProvider): Promise<SerializedFlow>;
    static deSerialize(flowConnect: FlowConnect, data: SerializedFlow, receive?: DataFetchProvider): Promise<Flow | undefined>;
}
export declare enum FlowState {
    Running = "Running",
    Idle = "Idle",
    Stopped = "Stopped"
}
export interface FlowOptions {
    name: string;
    rules: Rules;
    ruleColors?: RuleColors;
    id?: string;
}
export interface SerializedFlow {
    version?: string;
    id?: string;
    name?: string;
    rules?: Rules;
    ruleColors: SerializedRuleColors;
    nodes: SerializedNode[];
    groups: SerializedGroup[];
    connectors: SerializedConnector[];
    inputs: SerializedTunnelNode[];
    outputs: SerializedTunnelNode[];
}