import { ParseTree } from './parser';
import { Type, TypeEnv, Symbol } from './types';
import { Code, Language, Module } from './modules';
export declare abstract class Generator {
    protected code: Code;
    protected lang: Language | undefined;
    constructor(parent?: Generator);
    setLanguage(lang: Language): void;
    installModule(name: string, module: Module): void;
    init(): void;
    protected loadModule(name: string): Module | undefined;
    protected abstract visit(pt: ParseTree): Type;
    abstract generate(pt: ParseTree): Code;
    abstract define(key: string, type: string, code: string, option?: any): Symbol;
}
declare abstract class CodeWriter extends Generator {
    protected buffers: string[];
    protected indentLevel: number;
    constructor(parent?: CodeWriter);
    init(): void;
    protected abstract getSymbol(key: string): Symbol | undefined;
    protected push(c: string | string[]): void;
    protected pushLF(): void;
    protected pushSP(): void;
    protected pushEOS(): void;
    protected token(key: string): string;
    protected pushS(key: string): void;
    protected pushP(open: string, cs: string[] | string[][] | ParseTree[], close: string): void;
    protected pushIndent(msg?: string): void;
    protected incIndent(): void;
    protected decIndent(): void;
    generate(pt: ParseTree): Code;
    protected rewrite(source: string): string;
}
export declare class FunctionContext {
    isGlobalMain: boolean;
    name: string;
    params: string[];
    paramTypes: Type[];
    locals: string[];
    hasReturn: boolean;
    foundAsync: boolean;
    returnType: Type;
    loopLevel: number;
    constructor(name: string, paramTypes: Type[] | undefined, returnType: Type, isGlobalMain?: boolean);
    declName(name: string): void;
    definedFuncType(): Type;
    definedSymbol(name: string, options?: any): Symbol;
}
export declare class Environment extends CodeWriter {
    parent: Environment | undefined;
    env: {
        [key: string]: Symbol;
    };
    funcBase: FunctionContext;
    typeEnv: TypeEnv;
    varTypeId: number;
    constructor(parent?: Environment);
    init(): void;
    protected getRoot(): Environment;
    protected getAcceptMethod(pt: ParseTree): string;
    protected visit(pt: ParseTree): Type;
    undefinedParseTree(pt: ParseTree): Type;
    getSymbol(key: string): Symbol | undefined;
    hasSymbol(key: string): boolean;
    setSymbol(key: string, symbol: Symbol): Symbol;
    define(key: string, type: Type | string, code?: string, options?: any): Symbol;
    testModule(modules: any[]): void;
    protected inGlobal(): boolean;
    protected inLocal(): boolean;
    protected inLoop(): boolean;
    protected newTypeEnv(): TypeEnv;
    protected newVarType(pt: ParseTree): import("./types").VarType;
    typeCheck(pt: ParseTree, pat?: Type, tenv?: TypeEnv, options?: any): [string[], Type];
    private prevRow;
    protected pushT(pt: ParseTree, ty?: Type, infix?: boolean): Type;
    perror(pt: ParseTree, key: string, options?: any): void;
    untyped(): Type;
    testHasError(key: string): boolean;
    rewrite(source: string): string;
    stringfy(pt?: ParseTree): string;
}
export {};