/**
 * This module implements parsing / formatting routines for
 * Netlink and Generic Netlink structures.
 *
 * **Important:** These structures use the host endianness.
 * This module will serialize messages differently depending
 * on that.
 *
 * @module
 */
/// <reference types="node" />
export declare const readF64: (offset?: number | undefined) => number;
export declare const readF32: (offset?: number | undefined) => number;
export declare const readU64: (offset?: number | undefined) => bigint;
export declare const readS64: (offset?: number | undefined) => bigint;
export declare const readU32: (offset?: number | undefined) => number;
export declare const readS32: (offset?: number | undefined) => number;
export declare const readU16: (offset?: number | undefined) => number;
export declare const readS16: (offset?: number | undefined) => number;
export declare const readU8: (offset?: number | undefined) => number;
export declare const readS8: (offset?: number | undefined) => number;
export declare const readU32be: (offset?: number | undefined) => number;
export declare const readU16be: (offset?: number | undefined) => number;
export declare const writeF64: (value: number, offset?: number | undefined) => number;
export declare const writeF32: (value: number, offset?: number | undefined) => number;
export declare const writeU64: (value: bigint, offset?: number | undefined) => number;
export declare const writeS64: (value: bigint, offset?: number | undefined) => number;
export declare const writeU32: (value: number, offset?: number | undefined) => number;
export declare const writeS32: (value: number, offset?: number | undefined) => number;
export declare const writeU16: (value: number, offset?: number | undefined) => number;
export declare const writeS16: (value: number, offset?: number | undefined) => number;
export declare const writeU8: (value: number, offset?: number | undefined) => number;
export declare const writeS8: (value: number, offset?: number | undefined) => number;
export declare const writeU32be: (value: number, offset?: number | undefined) => number;
export declare const writeU16be: (value: number, offset?: number | undefined) => number;
export declare const ensureArray: (x: Uint8Array | Uint8Array[]) => Uint8Array[];
export declare function countLength(x: Uint8Array | Uint8Array[]): number;
/** Get the amount of padding (in bytes) to add after length */
export declare const padding: (x: number) => number;
/** Like {@link padding} but returns a zero-filled buffer of that length */
export declare const getPadding: (x: number) => Buffer;
/** Append necessary padding to data. THIS MODIFIES THE ORIGINAL ARRAY */
export declare function pad(x: Uint8Array[]): Uint8Array[];
/** Round the passed length up to align it */
export declare const align: (x: number) => number;
export declare type ParseResult<T> = {
    x: T;
    consumed: number;
};
/** Length of netlink headers */
export declare const HEADER_LENGTH = 16;
/** Header for Netlink messages */
export interface NetlinkHeader {
    /** Message length, including header */
    length: number;
    /** Message type */
    type: number;
    /** Message flags */
    flags: number;
    /** Sequence number */
    seq: number;
    /** Port number (i.e. pid) that sends the message */
    port: number;
}
/**
 * Parses a Netlink header
 * @param x Header data
 * @returns Parsed header
 * @throws If `x` contains less than `HEADER_LENGTH`
 */
export declare function parseHeader(r: Buffer): ParseResult<NetlinkHeader>;
/**
 * Encodes a Netlink header
 * @param x Header data
 * @returns Serialized header
 */
export declare function formatHeader(x: NetlinkHeader): Buffer;
/** Combination of a valid {@link NetlinkHeader} with payload */
export interface NetlinkMessage_ {
    /** Message type */
    type: number;
    /** Message flags */
    flags: number;
    /** Sequence number */
    seq: number;
    /** Port number (i.e. pid) that sends the message */
    port: number;
    /** Message payload */
    data: Uint8Array | Uint8Array[];
}
/** Combination of a valid {@link link NetlinkHeader} with payload */
export interface NetlinkMessage extends NetlinkMessage_ {
    data: Buffer;
}
export declare function formatMessage(x: NetlinkMessage_): Uint8Array[];
export declare function parseMessage(r: Buffer): ParseResult<NetlinkMessage>;
/**
 * Calls {@link parseMessage} repeatedly, ignoring padding
 * between messages, until there's no data left (other than padding).
 *
 * @param x Message data
 * @retrns Array of parsed messages
 */
export declare function parseMessages(r: Buffer): NetlinkMessage[];
export interface NetlinkErrorMessage {
    errno: number;
    code?: string;
    header: NetlinkHeader;
    tlvData?: Buffer;
}
export declare function parseError(r: Buffer, flags: number): NetlinkErrorMessage;
/** Netlink attribute (TLV) */
export interface NetlinkAttribute_ {
    /** True if the payload carries nested attributes */
    nested?: boolean;
    /** True if the payload is stored in network byte order */
    no?: boolean;
    /** Attribute type (14 bits) */
    type: number;
    /** Message payload */
    data: Uint8Array | Uint8Array[];
}
/** Netlink attribute (TLV) */
export interface NetlinkAttribute extends NetlinkAttribute_ {
    data: Buffer;
}
/**
 * Object allowing efficient construction of an attribute stream.
 */
export declare type StreamData = Uint8Array | Uint8Array[] | ((out: AttrStream) => any);
export declare class AttrStream {
    readonly bufs: Uint8Array[];
    private offset;
    emit(data: StreamData): void;
    push(type: number, data: StreamData): void;
}
export declare function formatAttribute(x: NetlinkAttribute_): Uint8Array[];
export declare function parseAttribute(r: Buffer): ParseResult<NetlinkAttribute>;
/**
 * Calls {@link parseMessage} repeatedly, supplying each result to
 * the passed callback and ignoring padding, until there's no
 * data left (other than padding).
 *
 * @param x Attributes stream data
 * @retrns Array of parsed messages
 */
export declare function parseAttributes(r: Buffer, fn: (item: NetlinkAttribute) => any): void;
export declare const getU8: (x: Buffer) => number;
export declare const putU8: (x: number) => Buffer;
export declare const getU16: (x: Buffer) => number;
export declare const putU16: (x: number) => Buffer;
export declare const getU32: (x: Buffer) => number;
export declare const putU32: (x: number) => Buffer;
export declare const getU64: (x: Buffer) => bigint;
export declare const putU64: (x: bigint) => Buffer;
export declare const getS8: (x: Buffer) => number;
export declare const putS8: (x: number) => Buffer;
export declare const getS16: (x: Buffer) => number;
export declare const putS16: (x: number) => Buffer;
export declare const getS32: (x: Buffer) => number;
export declare const putS32: (x: number) => Buffer;
export declare const getS64: (x: Buffer) => bigint;
export declare const putS64: (x: bigint) => Buffer;
export declare const getU16be: (x: Buffer) => number;
export declare const putU16be: (x: number) => Buffer;
export declare const getU32be: (x: Buffer) => number;
export declare const putU32be: (x: number) => Buffer;
export declare const getF32: (x: Buffer) => number;
export declare const putF32: (x: number) => Buffer;
export declare const getF64: (x: Buffer) => number;
export declare const putF64: (x: number) => Buffer;
export declare const getFlag: (x: Buffer) => true;
export declare const putFlag: (x: true) => Buffer;
export declare function getBool(x: Buffer): boolean;
export declare const putBool: (x: boolean) => Buffer;
export declare function getString(x: Buffer, options?: {
    encoding?: BufferEncoding;
    maxLength: number;
}): string;
export declare function putString(x: string, options?: {
    encoding?: BufferEncoding;
    maxLength: number;
}): Buffer;
export declare function getMap<T>(x: Buffer, fn: (item: Buffer) => T): Map<number, T>;
export declare type GetArrayOptions = {
    zero?: boolean;
};
export declare function getArray<T>(x: Buffer, fn: (item: Buffer) => T, options?: GetArrayOptions): T[];
export declare function putArray<T>(x: T[], fn: (item: T) => StreamData, options?: GetArrayOptions): StreamData;
export declare function putMap<T>(x: Map<number, T>, fn: (item: T) => StreamData): StreamData;
/**
 * Common base interface for parsed structs that are "expandable"; meaning
 * they could see new fields appended to them in future versions of the kernel.
 */
export interface BaseExpandableStruct {
    /**
     * Extra data present at the end of the struct, if any. This is normal for
     * fields that were added to the struct on newer versions of the kernel and
     * not yet added to the type definitions.
     *
     * **This is not part of the stable API**; depending on it may break your
     * code even on minor releases, since the new fields could be finally
     * added and no longer be present here. The type of this field could also
     * change in the future.
     */
    __unparsed?: Buffer;
}
/** Common base interface for parsed Netlink objects (series of attributes). */
export interface BaseObject {
    /**
     * List of attributes that were discarded when parsing because their
     * type did not match any known value (if any). This is normal for
     * attributes that have been implemented into the kernel and not yet
     * added to the type definitions. The main use of this field is to
     * preserve those attributes when the struct is reformatted; you may
     * otherwise ignore it or even want to remove it.
     *
     * **This is not part of the stable API**; depending on it may break
     * your code even on minor releases, since the new attributes
     * could be finally added and no longer be present here. The type of
     * this field could also change in the future. Right now every item
     * is a `[type, data]` pair (see {@link NetlinkAttribute}).
     */
    __unparsed?: [number, Buffer][];
}
export declare function getObject<T extends BaseObject>(x: Buffer, fns: {
    [key: number]: (data: Buffer, obj: T) => any;
}): T;
export declare function putObject<T extends BaseObject>(x: T, fns: {
    [key: string]: (data: AttrStream, obj: T) => any;
}): StreamData;
export declare function getEnum<R>(mapping: {
    [key: number]: string;
}, x: number): number | keyof R;
export declare function putEnum<R>(mapping: {
    [key in keyof R]: number;
}, x: number | keyof R): number;
/** Length of generic netlink headers */
export declare const GENL_HEADER_LENGTH = 4;
/** Header for Generic Netlink message payload */
export interface GenericNetlinkHeader {
    cmd: number;
    version: number;
    reserved?: number;
}
/**
 * Parses a Generic Netlink header
 * @param x Header data
 * @returns Parsed header
 * @throws If `x` contains less than `GENL_HEADER_LENGTH`
 */
export declare function parseGenlHeader(r: Buffer): ParseResult<GenericNetlinkHeader>;
/**
 * Encodes a Generic Netlink header
 * @param x Header data
 * @returns Serialized header
 */
export declare function formatGenlHeader(x: GenericNetlinkHeader): Buffer;