import * as types from './types';
export * from './types';
export type FieldBuilder = PrimitiveField<types.PrimitiveType> | RecordField | ArrayField | EnumField | MapField | FixedField | UnionField | ReferenceField;
type SubField = types.PrimitiveType | RecordField | ArrayField | EnumField | MapField | FixedField | UnionField | ReferenceField | NamedTypeField<types.PrimitiveType>;
export type AddNullablePrimitiveFieldInput<T extends types.PrimitiveType> = types.BaseFieldParams & {
    defaultValue?: types.DefaultPrimitiveTypes[T] | null;
    type: T;
    nullable: true;
};
export type AddPrimitiveFieldInput<T extends types.PrimitiveType> = types.BaseFieldParams & {
    defaultValue?: types.DefaultPrimitiveTypes[T];
    type: T;
    nullable?: false;
};
export type RecordFieldInput = types.NamedFieldParams & {
    defaultValue?: any;
    namespace?: string;
    nullable?: boolean;
};
export type ReferenceFieldInput = Omit<types.BaseFieldParams, 'order'> & {
    type: string;
    nullable?: boolean;
};
export type ArrayFieldInput = types.BaseFieldParams & {
    defaultValue?: any[] | null;
    type: SubField;
    nullable?: boolean;
};
export type UnionFieldInput = Pick<types.BaseFieldParams, 'name'> & {
    types: Array<SubField>;
    nullable?: boolean;
};
export type MapFieldInput = Omit<types.BaseFieldParams, 'order'> & {
    type: SubField;
    nullable?: boolean;
};
export type EnumFieldInput = Omit<types.NamedFieldParams, 'order'> & {
    type: string[];
    nullable?: boolean;
    namespace?: string;
    aliases?: string[];
    defaultValue?: string;
};
export type FixedFieldInput = Omit<types.NamedFieldParams, 'order' | 'doc'> & {
    size: number;
    nullable?: boolean;
    aliases?: string[];
};
export interface NamedFieldInput<T extends types.PrimitiveType> {
    type: T;
}
declare class BaseField {
    readonly name: string;
    readonly doc?: string;
    readonly order?: types.FieldOrder;
    readonly nullable?: boolean;
    readonly keyName: string;
    constructor({ params }: {
        params: types.NamedFieldParams & {
            nullable?: boolean;
        };
    });
}
export declare class ReferenceField extends BaseField {
    readonly type: string;
    readonly nullable?: boolean;
    constructor(params: ReferenceFieldInput);
    getType(): string;
    compile(): types.RecordFieldSerialized;
}
export declare class PrimitiveField<T extends types.PrimitiveType> extends BaseField {
    readonly type: T;
    readonly defaultValue?: types.DefaultPrimitiveTypes[T] | null;
    constructor(params: AddPrimitiveFieldInput<T> | AddNullablePrimitiveFieldInput<T>);
    getType(): types.PrimitiveType;
    compile(): types.RecordFieldSerialized;
}
export declare class EnumField extends BaseField {
    readonly nullable?: boolean;
    readonly namespace: string | undefined;
    readonly defaultValue: string | undefined;
    readonly aliases: string[] | undefined;
    readonly symbols: string[];
    constructor(params: EnumFieldInput);
    getType(): types.EnumType;
    compile(): types.RecordFieldSerialized;
}
export declare class FixedField extends BaseField {
    readonly nullable?: boolean;
    readonly aliases: string[] | undefined;
    readonly size: number;
    constructor(params: FixedFieldInput);
    getType(): types.FixedType;
    compile(): types.RecordFieldSerialized;
}
export declare class MapField extends BaseField {
    private readonly _type;
    readonly nullable?: boolean;
    constructor({ type, nullable, ...params }: MapFieldInput);
    getType(): types.MapType;
    compile(): types.RecordFieldSerialized;
}
export declare class UnionField extends BaseField {
    private readonly _types;
    readonly nullable?: boolean;
    constructor({ types, nullable, ...params }: UnionFieldInput);
    getType(): types.DefinedType[] | types.DefinedType;
    compile(): types.RecordFieldSerialized;
}
export declare class ArrayField extends BaseField {
    private readonly _type;
    readonly nullable?: boolean;
    readonly defaultValue?: any[] | null;
    constructor({ type, nullable, defaultValue, ...params }: ArrayFieldInput);
    getType(): types.ArrayType;
    compile(): types.RecordFieldSerialized;
}
export declare class NamedTypeField<T extends types.PrimitiveType> {
    private readonly _type;
    constructor({ type }: NamedFieldInput<T>);
    getType(): types.NamedType;
}
export declare class RecordField extends BaseField {
    namespace: string | undefined;
    baseField?: boolean;
    defaultValue?: any;
    readonly nullable?: boolean;
    private _fields;
    constructor(params: RecordFieldInput);
    addField(field: FieldBuilder): this;
    private renderNamespaceErrorMessage;
    compile(): types.RecordFieldSerialized;
    getType(): types.RecordType;
}
export declare class AvroSchemaBuilder {
    private readonly _record;
    constructor(name: string);
    record(namespace?: string): RecordField;
}