import * as wasm from './wasm';
import { Module } from './Module';
export { Module };
export interface Visitor<T> {
    visitConst(node: Const): T;
    visitUnreachable(node: Unreachable): T;
    visitNop(node: Nop): T;
    visitBlock(node: Block): T;
    visitLoop(node: Loop): T;
    visitIf(node: If): T;
    visitBranch(node: Branch): T;
    visitBranchIf(node: BranchIf): T;
    visitBranchTable(node: BranchTable): T;
    visitReturn(node: Return): T;
    visitCall(node: Call): T;
    visitCallIndirect(node: CallIndirect): T;
    visitDrop(node: Drop): T;
    visitSelect(node: Select): T;
    visitGetLocal(node: GetLocal): T;
    visitSetLocal(node: SetLocal): T;
    visitTeeLocal(node: TeeLocal): T;
    visitGetGlobal(node: GetGlobal): T;
    visitSetGlobal(node: GetGlobal): T;
    visitLoad(node: Load): T;
    visitStore(node: Store): T;
    visitCurrentMemory(node: CurrentMemory): T;
    visitGrowMemory(node: GrowMemory): T;
    visitUnaryExpression(node: UnaryExpression): T;
    visitBinaryExpression(node: BinaryExpression): T;
    visitFunctionType(node: FunctionType): T;
    visitImport(node: Import): T;
    visitExport(node: Export): T;
    visitGlobal(node: Global): T;
    visitFunction(node: Function): T;
    visitTable(node: Table): T;
    visitMemory(node: Memory): T;
    visitModule(node: Module): T;
}
export interface Node {
    accept<T>(visitor: Visitor<T>): T;
}
export interface Expression extends Node {
}
export interface Type extends Node {
    type: wasm.Type;
}
export declare class Const implements Expression {
    value: number;
    opcode: wasm.Opcode;
    constructor(value: number, opcode: wasm.Opcode);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Unreachable implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Nop implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Block implements Expression {
    children: Array<Expression>;
    returnType: wasm.Type;
    name: string;
    constructor(children: Array<Expression>, returnType: wasm.Type, name?: string);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Loop implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class If implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Branch implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class BranchIf implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class BranchTable implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Return implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Call implements Expression {
    target: Function | Import;
    args: Array<Expression>;
    constructor(target: Function | Import, args: Array<Expression>);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class CallIndirect implements Expression {
    target: Expression;
    args: Array<Expression>;
    type: FunctionType;
    constructor(target: Expression, args: Array<Expression>, type: FunctionType);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Drop implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Select implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class GetLocal implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class SetLocal implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class TeeLocal implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class GetGlobal implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class SetGlobal implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Load implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Store implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class CurrentMemory implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class GrowMemory implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class UnaryExpression implements Expression {
    accept<T>(visitor: Visitor<T>): T;
}
export declare class BinaryExpression implements Expression {
    left: Expression;
    opcode: wasm.Opcode;
    right: Expression;
    constructor(left: Expression, opcode: wasm.Opcode, right: Expression);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class FunctionType implements Type, Node {
    paramTypes: Array<wasm.Type>;
    type: wasm.Type;
    returnTypes: Array<wasm.Type>;
    constructor(paramTypes?: Array<wasm.Type>, returnTypes?: Array<wasm.Type> | wasm.Type);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Import {
    name: string;
    moduleName: string;
    fieldName: string;
    externalKind: wasm.ExternalKind;
    type: Type | wasm.Type;
    constructor(name: string, moduleName: string, fieldName: string, externalKind: wasm.ExternalKind, type: Type | wasm.Type);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Export {
    externalName: string;
    externalKind: wasm.ExternalKind;
    value: Function;
    constructor(externalName: string, externalKind: wasm.ExternalKind, value: Function);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Global {
    type: wasm.Type;
    init: Expression;
    immutable: boolean;
    constructor(type: wasm.Type, init: Expression, immutable?: boolean);
}
export interface Element {
    type: wasm.Type;
    name: string;
}
export declare class Function implements Element {
    name: string;
    functionType: FunctionType;
    localTypes: Array<wasm.Type>;
    body: Array<Expression>;
    type: wasm.Type;
    externalKind: wasm.ExternalKind;
    constructor(name: string, functionType: FunctionType, localTypes: Array<wasm.Type>, body: Array<Expression>);
}
export declare class Table implements Node {
    elements: Array<Element>;
    offset: Expression;
    constructor(elements: Array<Element>, offset: Expression);
    accept<T>(visitor: Visitor<T>): T;
}
export declare class Data {
    value: string;
    offset: Expression;
    constructor(value: string, offset: Expression);
}
export declare class Memory {
    initialSize: number;
    maxSize: number;
    segments: Array<Data>;
    constructor(initialSize: number, maxSize: number, segments: Array<Data>);
}