import { LogicConditionClause } from '../../Types/Logic';
import { Graph, GraphEdge, GraphNode } from '../Graphs';
import { DominatorTree } from './DominatorTree';
import { LogicLabel, LogicCommandNode, LogicGotoNode, LogicIfNode, LogicASTNode } from './LogicDecompile';
/**
 * An intermediate data structure used during decompilation.  A basic block is a consecutive set
 * of simple commands (i.e. not conditionals or gotos) followed optionally by a conditional or
 * goto. It also has references to its entry and exit vertices in the control flow graph.
 *
 * See also: https://en.wikipedia.org/wiki/Basic_block
 */
declare type BasicBlockCommon = {
    id: string;
    label?: LogicLabel;
    commands: LogicCommandNode[];
    entryPoints: Set<BasicBlockEdge>;
};
export declare type SinglePathBasicBlock = BasicBlockCommon & {
    type: 'singlePathBasicBlock';
    next?: NextBasicBlockEdge;
    metadata: {
        gotoNode?: LogicGotoNode;
    };
};
export declare type IfExitBasicBlock = BasicBlockCommon & {
    type: 'ifExitBasicBlock';
    clauses: LogicConditionClause[];
    then?: ThenBasicBlockEdge;
    else?: ElseBasicBlockEdge;
    metadata: {
        ifNode: LogicIfNode;
    };
};
export declare type BasicBlock = SinglePathBasicBlock | IfExitBasicBlock;
declare type BasicBlockEdgeCommon = GraphEdge<BasicBlock>;
export declare type NextBasicBlockEdge = Omit<BasicBlockEdgeCommon, 'from'> & {
    type: 'next';
    from: SinglePathBasicBlock;
};
export declare type ThenBasicBlockEdge = Omit<BasicBlockEdgeCommon, 'from'> & {
    type: 'then';
    from: IfExitBasicBlock;
};
export declare type ElseBasicBlockEdge = Omit<BasicBlockEdgeCommon, 'from'> & {
    type: 'else';
    from: IfExitBasicBlock;
};
export declare type BasicBlockEdge = NextBasicBlockEdge | ThenBasicBlockEdge | ElseBasicBlockEdge;
export declare type ReverseCFGNode = GraphNode & {
    entries: ReverseCFGEdge[];
    exits: ReverseCFGEdge[];
};
export declare type ReverseCFGEdge = GraphEdge<ReverseCFGNode>;
export declare class ReverseCFG extends Graph<ReverseCFGNode> {
    getInwardEdges(node: ReverseCFGNode): ReverseCFGEdge[];
    getOutwardEdges(node: ReverseCFGNode): ReverseCFGEdge[];
}
export declare class BasicBlockGraph extends Graph<BasicBlock, BasicBlockEdge> {
    static fromAST(rootNode: LogicASTNode): BasicBlockGraph;
    getInwardEdges(block: BasicBlock): BasicBlockEdge[];
    getOutwardEdges(block: BasicBlock): BasicBlockEdge[];
    getNodeName(block: BasicBlock): string;
    getEdgeLabel(edge: BasicBlockEdge): string;
    buildDominatorTree(): DominatorTree<BasicBlock>;
    buildPostDominatorTree(): DominatorTree<ReverseCFGNode>;
    buildReverseCFG(): ReverseCFG;
}
export declare function formatKeyValuePairs<T>(obj: T | undefined, keys: (keyof T)[]): string;
export declare function basicBlockDebugName(block: BasicBlock): string;
export declare function removeEdge(edge: BasicBlockEdge): void;
export declare function attachNext(block: SinglePathBasicBlock, nextBlock: BasicBlock): void;
export declare function attachThen(block: IfExitBasicBlock, nextBlock: BasicBlock): void;
export declare function attachElse(block: IfExitBasicBlock, nextBlock: BasicBlock): void;
export declare function replaceEdge(edge: BasicBlockEdge, newTarget: BasicBlock): void;
export {};