import { Node, NodeComment, NodeContainer, NodeData, NodeFunction, NodeRawFunction, NodeSequence, NodeText } from '../parser/Node';
import { ParserSequenceConfig } from '../parser/Parser';
import { CompilerPlugin } from '../plugin/CompilerPlugin';
import { Location } from '../source/Location';
import { Source } from '../source/Source';
import { CompilerDelegate } from './CompilerDelegate';
export declare type NodeCompiler<T extends Node> = (delegate: CompilerDelegate, node: T) => void;
export declare type FunctionCompiler = NodeCompiler<NodeFunction>;
export declare type SequenceCompiler = NodeCompiler<NodeSequence>;
export declare type RawFunctionCompiler = NodeCompiler<NodeRawFunction>;
export declare class Compiler {
    private builder;
    private footerBuilder;
    private functions;
    private sequences;
    private rawFunctions;
    private parserSequences;
    private delegate;
    addPlugin(cons: new () => CompilerPlugin): void;
    addFunction(name: string, compiler: FunctionCompiler): void;
    addSimpleFunction(name: string, min: number, max?: number): void;
    addSequence(name: string, config: ParserSequenceConfig, compiler: SequenceCompiler): void;
    addRawFunction(name: string, compiler: RawFunctionCompiler): void;
    addDefaults(): void;
    compile(source: Source): string;
    protected compileContainer(node: NodeContainer): void;
    protected compileComment(node: NodeComment): void;
    protected compileText(node: NodeText): void;
    protected compileData(node: NodeData): void;
    protected compileFunction(node: NodeFunction): void;
    protected compileRawFunction(node: NodeRawFunction): void;
    protected compileSequence(node: NodeSequence): void;
    protected compileNode(node: Node): void;
    protected error(message: string, node: Node, position?: Partial<Location>): never;
}