import { ParseTree } from './parser';
export declare class TypeEnv {
    parent: TypeEnv | null;
    env: any;
    serial: number;
    constructor(parent?: TypeEnv | null);
    newVarType(name: string): void;
    setDRef(key: string, unified: DRef): void;
    getDRef(key: string, varType: VarType): DRef;
}
declare class DRef {
    resolved: Type | null;
    parent: VarType;
    constructor(parent: VarType);
    match(tenv: TypeEnv, ty: Type): VarType | Type | null;
    matchedType(matched?: Type | undefined): VarType | Type | null;
    merge(tenv: TypeEnv, dref2: DRef): VarType | Type | null;
    unify(tenv: TypeEnv, dref2: DRef): DRef;
}
export declare class Type {
    tid: string;
    memoed: boolean;
    value: any;
    constructor(tid: string, value: any);
    toString(): string;
    static key(open: string, ts: Type[], close: string): string;
    match(tenv: TypeEnv, ty: Type): Type | null;
    matchEach(tenv: TypeEnv, ty: Type): Type | null;
    containsResolvingType(): boolean;
    resolved(tenv: TypeEnv): Type;
    paramTypes(): Type[];
    getReturnType(): Type;
    getParameterSize(): number;
    getParameterType(index: number): Type;
    getValue(): any;
    isOptional(): boolean;
    is(name: string): boolean;
    isBoolType(): boolean;
    isNumberType(): boolean;
    isStringType(): boolean;
    isFuncType(): boolean;
    static memoType(key: string, makeType: () => Type): Type;
    static newVarType(varname: string, id: number): VarType;
    static newFuncType(paramType: Type, returnType: Type): Type;
    static newParamType(base: string, ...ts: Type[]): Type;
    static newArrayType(ty: Type): Type;
    static newTupleType(...ts: Type[]): Type;
    static newUnionType(...ts: Type[]): Type;
    static of(s: string): Type;
    static parseOf(s: string): Type;
}
export declare class VarType extends Type {
    serial: number;
    constructor(varname: string, serial: number);
    matchEach(tenv: TypeEnv, ty: Type): Type | null;
    resolved(tenv: TypeEnv): this | Type;
}
export declare class Symbol {
    type: Type;
    source: ParseTree | null;
    code: string;
    options: any | undefined;
    constructor(type: Type, code?: string, options?: any);
    format(params?: string[]): string;
    static Async: {
        isAsync: boolean;
    };
}
export {};