import { Import } from './import';
import { Options } from './util';
export declare class Model {
    readonly imports: Import[];
    readonly interfaces: Interface[];
    readonly namespace: string;
    readonly path: string;
    constructor(options: ModelOptions);
}
export declare type ModelOptions = Options<Model, 'imports' | 'interfaces'>;
export declare class Interface {
    readonly base: string | null;
    readonly identifier: string;
    readonly namespace: string;
    readonly generics: Generic[];
    readonly properties: Property[];
    readonly ref: string;
    constructor(options: InterfaceOptions);
}
export declare type InterfaceOptions = Options<Interface, 'generics' | 'properties'>;
declare abstract class TypeRef {
    readonly refs: string[];
    protected _type: string;
    get type(): string;
    set type(value: string);
    protected _default: string;
    get default(): any;
    set default(value: any);
    constructor(options: TypeRefOptions);
    setDefault(value: string): void;
    setType(value: string): void;
}
declare type TypeRefOptionalKeys = 'default' | 'refs';
declare type TypeRefOptions = Options<TypeRef, TypeRefOptionalKeys>;
export declare class Generic extends TypeRef {
    constructor(options: GenericOptions);
}
export declare type GenericOptions = Options<Generic, TypeRefOptionalKeys>;
export declare class Property extends TypeRef {
    readonly name: string;
    private _optional;
    get optional(): '' | '?';
    set optional(value: '' | '?');
    constructor(options: PropertyOptions);
    setOptional(isOptional: boolean): void;
}
export declare type PropertyOptions = Options<Property, TypeRefOptionalKeys | 'optional'>;
export {};