export declare abstract class Node {
    protected children: Node[];
    constructor();
    addChild<T extends Node>(child: T): T;
    addChildren<T extends Node>(children: T[]): void;
    abstract serialize(): string;
}
export declare class Root extends Node {
    readonly libName: string;
    private imports;
    private interfaceNames;
    private main?;
    constructor(libName?: string);
    addChild<T extends Node>(child: T): T;
    addImports(path: string, imports: string[]): void;
    addInterface(name: string, extend?: string[]): Interface;
    addMain(name?: string, options?: Partial<MainOptions>): MainClass;
    getMain(): MainClass;
    addGenericInterfaces(): void;
    serialize(): string;
}
export declare class Imports extends Node {
    private imports;
    addImports(path: string, imports: string[]): ImportStatement;
    serialize(): string;
}
export declare class ImportStatement extends Node {
    readonly moduleName: string;
    private imports;
    constructor(moduleName: string, imports?: string[]);
    addImports(imports: string[]): void;
    serialize(): string;
}
export declare type Valuespace = Type | string;
export interface Type {
    getType(): string;
}
export declare class Plain implements Type {
    readonly text: string;
    constructor(text: string);
    getType(): string;
}
export declare class Generic implements Type {
    private name;
    private inner;
    constructor(name: Valuespace, inner: Valuespace);
    getType(): string;
}
export declare class Function extends Node implements Type {
    readonly name: string;
    readonly args: [string, Type][];
    readonly ret: Type;
    constructor(name: string, args?: [string, Type][], ret?: Type);
    getType(separator?: string): string;
    serialize(): string;
}
export declare class List implements Type {
    readonly elementType: Type;
    constructor(elementType: Type);
    getType(): string;
}
export declare class Literal implements Type {
    private members;
    constructor(...members: Valuespace[]);
    getType(): string;
}
export declare class Interface extends Node implements Type {
    readonly name: string;
    readonly extend: string[];
    constructor(name: string, extend?: string[]);
    getType(): string;
    allOptional(): boolean;
    serialize(): string;
}
export interface MainOptions {
    base: string;
    withConnect: boolean;
}
export declare class MainClass extends Interface {
    readonly name: string;
    private connectGen;
    private readonly options;
    constructor(root: Root, name?: string, options?: Partial<MainOptions>);
    serialize(): string;
}
export interface MemberOpts {
    docstring: string;
    required: boolean;
}
export declare class Member extends Node {
    readonly name: string;
    private type;
    private options;
    constructor(name: string, type: Valuespace, options?: Partial<MemberOpts>);
    get isRequired(): boolean;
    formatDocstring(): string;
    serialize(): string;
}
export declare class Tree extends Node {
    readonly name: string;
    constructor(name: string);
    serialize(): string;
}
export declare class ArrayTree extends Tree {
    serialize(): string;
}
export interface CommandOpts {
    docstring: string;
    multiline: boolean;
}
export declare class Command extends Node {
    readonly name: string;
    readonly params?: Interface | undefined;
    private retval?;
    private options;
    constructor(name: string, params?: Interface | undefined, retval?: Valuespace, options?: Partial<CommandOpts>);
    formatDocstring(): string;
    serialize(): string;
}