import { Name } from '../../common/name';
import { Serializable } from '../../common/serializable';
import { TypedBinaryParser } from '../../common/typed-binary-parser';
import { ResourceRecordClass } from './common/resource-record.class';
import { ResourceRecordType } from './common/resource-record.type';
import { ResourceRecordA } from './impl/a.resource-record';
import { ResourceRecordOPT } from './impl/opt.resource-record';
export declare namespace ResourceRecord {
    type Like = Pick<ResourceRecord, 'name' | 'type' | 'class' | 'ttl' | 'data'>;
    type Type = ResourceRecordType;
    namespace Type {
        type Readable = ResourceRecordType.Readable;
        type Like = ResourceRecordType.Like;
    }
    type Class = ResourceRecordClass;
    namespace Class {
        type Readable = ResourceRecordClass.Readable;
        type Like = ResourceRecordClass.Like;
    }
}
type StaticType = typeof ResourceRecordType & Record<ResourceRecord.Type.Readable, ResourceRecordType>;
type StaticClass = typeof ResourceRecordClass & Record<ResourceRecord.Class.Readable, ResourceRecordClass>;
export declare class ResourceRecord<T extends Serializable = Serializable> implements ResourceRecord<T>, Serializable {
    readonly name: Name;
    readonly type: ResourceRecord.Type.Like;
    readonly ttl: number;
    readonly data: T;
    static Class: StaticClass;
    static Type: StaticType;
    static A: typeof ResourceRecordA;
    static OPT: typeof ResourceRecordOPT;
    readonly class: ResourceRecord.Class.Like;
    private constructor();
    private static implements;
    static from(parsed: ResourceRecord): ResourceRecordA | ResourceRecordOPT | ResourceRecord<Serializable>;
    serialize(): Buffer;
}
export declare const resourceRecordParser: TypedBinaryParser<ResourceRecord<Serializable>>;
export {};
//# sourceMappingURL=resource-record.d.ts.map