import { ASTNode, ASTNodeConstructor } from "./ast_node";
import { SourceUnit } from "./implementation/meta/source_unit";
export type FileMap = Map<string, Uint8Array>;
export interface ASTNodeProcessor<T extends ASTNode> {
    process(reader: ASTReader, config: ASTReaderConfiguration, raw: any): ConstructorParameters<ASTNodeConstructor<T>>;
}
export interface ASTNodePostprocessor<T extends ASTNode> {
    process(node: T, context: ASTContext, sources?: FileMap): void;
    isSupportedNode(node: ASTNode): node is T;
}
export interface ASTReadingRule {
    constructor: ASTNodeConstructor<ASTNode>;
    processor: ASTNodeProcessor<ASTNode>;
}
export interface ASTReadingRules {
    Default: ASTReadingRule;
    [type: string]: ASTReadingRule;
}
export type ASTReadingSignatureDetector = (raw: any) => string;
export interface ASTReaderConfiguration {
    signatureDetector: ASTReadingSignatureDetector;
    rules: ASTReadingRules;
}
export declare class ASTContext {
    /**
     * ID to distinct different contexts
     */
    id: number;
    /**
     * Map from ID number to the `AST` node with same ID in tree
     */
    map: Map<number, ASTNode>;
    constructor(...nodes: ASTNode[]);
    /**
     * Max ID of the registered nodes
     */
    get lastId(): number;
    get nodes(): Iterable<ASTNode>;
    register(...nodes: ASTNode[]): void;
    unregister(...nodes: ASTNode[]): void;
    locate(id: number): ASTNode;
    require(id: number): ASTNode;
    requireType<T extends ASTNode>(id: number, constr: ASTNodeConstructor<T>): T;
    contains(node: ASTNode): boolean;
}
export declare class ASTPostprocessor {
    nodePostprocessors: Array<ASTNodePostprocessor<ASTNode>>;
    constructor(nodePostProcessors?: ASTNodePostprocessor<ASTNode>[]);
    getPostprocessorsForNode(node: ASTNode): Array<ASTNodePostprocessor<ASTNode>>;
    processNode(node: ASTNode, context: ASTContext, sources?: FileMap): void;
    processContext(context: ASTContext, sources?: FileMap): void;
}
export declare enum ASTKind {
    Any = "any",
    Modern = "modern",
    Legacy = "legacy"
}
export declare class ASTReader {
    /**
     * A tree context for the processed nodes
     */
    context: ASTContext;
    /**
     * A tree postprocessor to apply for the processed nodes
     */
    postprocessor: ASTPostprocessor;
    constructor(context?: ASTContext, postprocessor?: ASTPostprocessor);
    /**
     * Takes a Solc-compiler JSON output data and reads it to produce
     * universal AST node tree.
     *
     * @param data      Compiler output data to process.
     * @param kind      Kind of an AST tree (legacy, modern or any).
     * @param sources   Map with the source file names as keys
     *                  and corresponding source content strings as values.
     *
     * @returns An array of `SourceUnit`s for each of the source entries in the input.
     */
    read(data: any, kind?: ASTKind, sources?: FileMap): SourceUnit[];
    /**
     * Takes a raw Solc node object and produces
     * corresponding universal AST node instance.
     */
    convert(raw: any, config: ASTReaderConfiguration): ASTNode;
    /**
     * Takes an array of raw Solc node objects and produces
     * array of corresponding universal AST node instances.
     *
     * If input is not an array, then the empty array is returned.
     */
    convertArray(array: any, config: ASTReaderConfiguration): ASTNode[];
}
//# sourceMappingURL=ast_reader.d.ts.map