/// <reference types="node" />
import { BaseObject, BaseExpandableStruct, StreamData } from '../structs';
/** This struct should be in sync with struct rtnl_link_stats64 */
export interface LinkStats extends BaseExpandableStruct {
    /** total packets received */
    rxPackets?: number;
    /** total packets transmitted */
    txPackets?: number;
    /** total bytes received */
    rxBytes?: number;
    /** total bytes transmitted */
    txBytes?: number;
    /** bad packets received */
    rxErrors?: number;
    /** packet transmit problems */
    txErrors?: number;
    /** no space in linux buffers */
    rxDropped?: number;
    /** no space available in linux */
    txDropped?: number;
    /** multicast packets received */
    multicast?: number;
    collisions?: number;
    rxLengthErrors?: number;
    /** receiver ring buff overflow */
    rxOverErrors?: number;
    /** recved pkt with crc error */
    rxCrcErrors?: number;
    /** recv'd frame alignment error */
    rxFrameErrors?: number;
    /** recv'r fifo overrun */
    rxFifoErrors?: number;
    /** receiver missed packet */
    rxMissedErrors?: number;
    txAbortedErrors?: number;
    txCarrierErrors?: number;
    txFifoErrors?: number;
    txHeartbeatErrors?: number;
    txWindowErrors?: number;
    rxCompressed?: number;
    txCompressed?: number;
}
/** Parses the attributes of a {@link LinkStats} object */
export declare function parseLinkStats(r: Buffer): LinkStats;
/** Encodes a {@link LinkStats} object into a stream of attributes */
export declare function formatLinkStats(x: LinkStats, r?: Buffer): Buffer;
export declare const __MINLENGTH_LinkStats = 92;
/** The main device statistics structure */
export interface LinkStats64 extends BaseExpandableStruct {
    /** total packets received */
    rxPackets?: bigint;
    /** total packets transmitted */
    txPackets?: bigint;
    /** total bytes received */
    rxBytes?: bigint;
    /** total bytes transmitted */
    txBytes?: bigint;
    /** bad packets received */
    rxErrors?: bigint;
    /** packet transmit problems */
    txErrors?: bigint;
    /** no space in linux buffers */
    rxDropped?: bigint;
    /** no space available in linux */
    txDropped?: bigint;
    /** multicast packets received */
    multicast?: bigint;
    collisions?: bigint;
    rxLengthErrors?: bigint;
    /** receiver ring buff overflow */
    rxOverErrors?: bigint;
    /** recved pkt with crc error */
    rxCrcErrors?: bigint;
    /** recv'd frame alignment error */
    rxFrameErrors?: bigint;
    /** recv'r fifo overrun */
    rxFifoErrors?: bigint;
    /** receiver missed packet */
    rxMissedErrors?: bigint;
    txAbortedErrors?: bigint;
    txCarrierErrors?: bigint;
    txFifoErrors?: bigint;
    txHeartbeatErrors?: bigint;
    txWindowErrors?: bigint;
    rxCompressed?: bigint;
    txCompressed?: bigint;
}
/** Parses the attributes of a {@link LinkStats64} object */
export declare function parseLinkStats64(r: Buffer): LinkStats64;
/** Encodes a {@link LinkStats64} object into a stream of attributes */
export declare function formatLinkStats64(x: LinkStats64, r?: Buffer): Buffer;
export declare const __MINLENGTH_LinkStats64 = 184;
/** The struct should be in sync with struct ifmap */
export interface LinkInterfaceMap {
    memStart?: bigint;
    memEnd?: bigint;
    baseAddr?: bigint;
    irq?: number;
    dma?: number;
    port?: number;
}
/** Parses the attributes of a {@link LinkInterfaceMap} object */
export declare function parseLinkInterfaceMap(r: Buffer): LinkInterfaceMap;
/** Encodes a {@link LinkInterfaceMap} object into a stream of attributes */
export declare function formatLinkInterfaceMap(x: LinkInterfaceMap, r?: Buffer): Buffer;
export declare const __LENGTH_LinkInterfaceMap = 28;
export interface LinkAttrs extends BaseObject {
    address?: Buffer;
    broadcast?: Buffer;
    ifname?: string;
    mtu?: number;
    link?: Buffer;
    qdisc?: string;
    stats?: LinkStats;
    cost?: Buffer;
    priority?: Buffer;
    master?: number;
    /** Wireless Extension event - see wireless.h */
    wireless?: Buffer;
    /** Protocol specific information for a link */
    protinfo?: Map<number, Buffer>;
    txqlen?: number;
    map?: Buffer;
    weight?: number;
    operstate?: number;
    linkmode?: number;
    linkinfo?: Buffer;
    netNsPid?: number;
    ifalias?: string;
    /** Number of VFs if device is SR-IOV PF */
    numVf?: number;
    vfinfoList?: VirtualFunctionList;
    stats64?: LinkStats64;
    vfPorts?: PortList;
    portSelf?: Port;
    afSpec?: Map<number, Buffer>;
    /** Group the device belongs to */
    group?: number;
    netNsFd?: number;
    /** Extended info mask, VFs, etc */
    extMask?: Buffer;
    /** Promiscuity count: > 0 means acts PROMISC */
    promiscuity?: number;
    numTxQueues?: number;
    numRxQueues?: number;
    carrier?: number;
    physPortId?: Buffer;
    carrierChanges?: number;
    physSwitchId?: Buffer;
    linkNetnsid?: number;
    physPortName?: string;
    protoDown?: Buffer;
    gsoMaxSegs?: number;
    gsoMaxSize?: number;
    __pad?: Buffer;
    xdp?: Xdp;
    event?: Buffer;
    newNetnsid?: Buffer;
    /** new alias for IFLA_IF_NETNSID */
    targetNetnsid?: number;
    carrierUpCount?: number;
    carrierDownCount?: number;
    newIfindex?: number;
    minMtu?: number;
    maxMtu?: number;
    propList?: Buffer;
    /** Alternative ifname */
    altIfname?: string;
    permAddress?: Buffer;
}
/** Parses the attributes of a {@link LinkAttrs} object */
export declare function parseLinkAttrs(r: Buffer): LinkAttrs;
/** Encodes a {@link LinkAttrs} object into a stream of attributes */
export declare function formatLinkAttrs(x: LinkAttrs): StreamData;
export interface LinkProtocolInfoInet extends BaseObject {
    conf?: Buffer;
}
/** Parses the attributes of a {@link LinkProtocolInfoInet} object */
export declare function parseLinkProtocolInfoInet(r: Buffer): LinkProtocolInfoInet;
/** Encodes a {@link LinkProtocolInfoInet} object into a stream of attributes */
export declare function formatLinkProtocolInfoInet(x: LinkProtocolInfoInet): StreamData;
/** Subtype attributes for IFLA_PROTINFO */
export interface LinkProtocolInfoInet6 extends BaseObject {
    /** link flags */
    flags?: number;
    /** sysctl parameters */
    conf?: Buffer;
    /** statistics */
    stats?: Buffer;
    /** MC things. What of them? */
    mcast?: Buffer;
    /** time values and max reasm size */
    cacheinfo?: Buffer;
    /** statistics (icmpv6) */
    icmp6stats?: Buffer;
    /** device token */
    token?: Buffer;
    /** implicit address generator mode */
    addrGenMode?: number;
}
/** Parses the attributes of a {@link LinkProtocolInfoInet6} object */
export declare function parseLinkProtocolInfoInet6(r: Buffer): LinkProtocolInfoInet6;
/** Encodes a {@link LinkProtocolInfoInet6} object into a stream of attributes */
export declare function formatLinkProtocolInfoInet6(x: LinkProtocolInfoInet6): StreamData;
export declare enum In6AddrGenMode {
    EUI64 = 0,
    NONE = 1,
    STABLE_PRIVACY = 2,
    RANDOM = 3
}
/** Bridge section */
export interface Bridge extends BaseObject {
    forwardDelay?: Buffer;
    helloTime?: Buffer;
    maxAge?: Buffer;
    ageingTime?: Buffer;
    stpState?: Buffer;
    priority?: Buffer;
    vlanFiltering?: Buffer;
    vlanProtocol?: Buffer;
    groupFwdMask?: Buffer;
    rootId?: Buffer;
    bridgeId?: Buffer;
    rootPort?: Buffer;
    rootPathCost?: Buffer;
    topologyChange?: Buffer;
    topologyChangeDetected?: Buffer;
    helloTimer?: Buffer;
    tcnTimer?: Buffer;
    topologyChangeTimer?: Buffer;
    gcTimer?: Buffer;
    groupAddr?: Buffer;
    fdbFlush?: Buffer;
    mcastRouter?: Buffer;
    mcastSnooping?: Buffer;
    mcastQueryUseIfaddr?: Buffer;
    mcastQuerier?: Buffer;
    mcastHashElasticity?: Buffer;
    mcastHashMax?: Buffer;
    mcastLastMemberCnt?: Buffer;
    mcastStartupQueryCnt?: Buffer;
    mcastLastMemberIntvl?: Buffer;
    mcastMembershipIntvl?: Buffer;
    mcastQuerierIntvl?: Buffer;
    mcastQueryIntvl?: Buffer;
    mcastQueryResponseIntvl?: Buffer;
    mcastStartupQueryIntvl?: Buffer;
    nfCallIptables?: Buffer;
    nfCallIp6tables?: Buffer;
    nfCallArptables?: Buffer;
    vlanDefaultPvid?: Buffer;
    __pad?: Buffer;
    vlanStatsEnabled?: Buffer;
    mcastStatsEnabled?: Buffer;
    mcastIgmpVersion?: Buffer;
    mcastMldVersion?: Buffer;
    vlanStatsPerPort?: Buffer;
    multiBoolopt?: Buffer;
}
/** Parses the attributes of a {@link Bridge} object */
export declare function parseBridge(r: Buffer): Bridge;
/** Encodes a {@link Bridge} object into a stream of attributes */
export declare function formatBridge(x: Bridge): StreamData;
export interface BridgeId {
    prio?: number[];
    /** ETH_ALEN */
    addr?: number[];
}
/** Parses the attributes of a {@link BridgeId} object */
export declare function parseBridgeId(r: Buffer): BridgeId;
/** Encodes a {@link BridgeId} object into a stream of attributes */
export declare function formatBridgeId(x: BridgeId, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeId = 8;
export declare enum BridgePortMode {
    UNSPEC = 0,
    HAIRPIN = 1
}
export interface BridgePort extends BaseObject {
    /** Spanning tree state */
    state?: number;
    /** Spanning tree priority */
    priority?: number;
    /** Spanning tree cost */
    cost?: number;
    /** mode (hairpin) */
    mode?: number;
    /** bpdu guard */
    guard?: number;
    /** root port protection */
    protect?: number;
    /** multicast fast leave */
    fastLeave?: number;
    /** mac learning */
    learning?: number;
    /** flood unicast traffic */
    unicastFlood?: number;
    /** proxy ARP */
    proxyarp?: Buffer;
    /** mac learning sync from device */
    learningSync?: number;
    /** proxy ARP for Wi-Fi */
    proxyarpWifi?: Buffer;
    /** designated root */
    rootId?: Buffer;
    /** designated bridge */
    bridgeId?: Buffer;
    designatedPort?: Buffer;
    designatedCost?: Buffer;
    id?: Buffer;
    no?: Buffer;
    topologyChangeAck?: Buffer;
    configPending?: Buffer;
    messageAgeTimer?: Buffer;
    forwardDelayTimer?: Buffer;
    holdTimer?: Buffer;
    flush?: Buffer;
    multicastRouter?: Buffer;
    __pad?: Buffer;
    mcastFlood?: Buffer;
    mcastToUcast?: Buffer;
    vlanTunnel?: Buffer;
    bcastFlood?: Buffer;
    groupFwdMask?: Buffer;
    neighSuppress?: Buffer;
    isolated?: Buffer;
    backupPort?: Buffer;
}
/** Parses the attributes of a {@link BridgePort} object */
export declare function parseBridgePort(r: Buffer): BridgePort;
/** Encodes a {@link BridgePort} object into a stream of attributes */
export declare function formatBridgePort(x: BridgePort): StreamData;
export interface CacheInfo {
    maxReasmLen?: number;
    /** ipv6InterfaceTable updated timestamp */
    tstamp?: number;
    reachableTime?: number;
    retransTime?: number;
}
/** Parses the attributes of a {@link CacheInfo} object */
export declare function parseCacheInfo(r: Buffer): CacheInfo;
/** Encodes a {@link CacheInfo} object into a stream of attributes */
export declare function formatCacheInfo(x: CacheInfo, r?: Buffer): Buffer;
export declare const __LENGTH_CacheInfo = 16;
export interface Info extends BaseObject {
    kind?: string;
    data?: Buffer;
    xstats?: Buffer;
    slaveKind?: string;
    slaveData?: Buffer;
}
/** Parses the attributes of a {@link Info} object */
export declare function parseInfo(r: Buffer): Info;
/** Encodes a {@link Info} object into a stream of attributes */
export declare function formatInfo(x: Info): StreamData;
/** VLAN section */
export interface Vlan extends BaseObject {
    id?: number;
    flags?: Buffer;
    egressQos?: Buffer;
    ingressQos?: Buffer;
    protocol?: number;
}
/** Parses the attributes of a {@link Vlan} object */
export declare function parseVlan(r: Buffer): Vlan;
/** Encodes a {@link Vlan} object into a stream of attributes */
export declare function formatVlan(x: Vlan): StreamData;
export interface VlanFlagsMask {
    flags?: number;
    mask?: number;
}
/** Parses the attributes of a {@link VlanFlagsMask} object */
export declare function parseVlanFlagsMask(r: Buffer): VlanFlagsMask;
/** Encodes a {@link VlanFlagsMask} object into a stream of attributes */
export declare function formatVlanFlagsMask(x: VlanFlagsMask, r?: Buffer): Buffer;
export declare const __LENGTH_VlanFlagsMask = 8;
export interface VlanQos extends BaseObject {
    mapping?: Buffer;
}
/** Parses the attributes of a {@link VlanQos} object */
export declare function parseVlanQos(r: Buffer): VlanQos;
/** Encodes a {@link VlanQos} object into a stream of attributes */
export declare function formatVlanQos(x: VlanQos): StreamData;
export interface VlanQosMapping {
    from?: number;
    to?: number;
}
/** Parses the attributes of a {@link VlanQosMapping} object */
export declare function parseVlanQosMapping(r: Buffer): VlanQosMapping;
/** Encodes a {@link VlanQosMapping} object into a stream of attributes */
export declare function formatVlanQosMapping(x: VlanQosMapping, r?: Buffer): Buffer;
export declare const __LENGTH_VlanQosMapping = 8;
/** MACVLAN section */
export interface Macvlan extends BaseObject {
    mode?: number;
    flags?: number;
    macaddrMode?: number;
    macaddr?: Buffer;
    macaddrData?: Buffer;
    macaddrCount?: number;
}
/** Parses the attributes of a {@link Macvlan} object */
export declare function parseMacvlan(r: Buffer): Macvlan;
/** Encodes a {@link Macvlan} object into a stream of attributes */
export declare function formatMacvlan(x: Macvlan): StreamData;
export interface MacvlanMode {
    /** don't talk to other macvlans */
    private?: true;
    /** talk to other ports through ext bridge */
    vepa?: true;
    /** talk to bridge ports directly */
    bridge?: true;
    /** take over the underlying device */
    passthru?: true;
    /** use source MAC address list to assign */
    source?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link MacvlanMode} bitmask */
export declare function parseMacvlanMode(r: number): MacvlanMode;
/** Encodes a {@link MacvlanMode} bitmask */
export declare function formatMacvlanMode(x: MacvlanMode): number;
export declare enum MacvlanMacaddrMode {
    ADD = 0,
    DEL = 1,
    FLUSH = 2,
    SET = 3
}
/** VRF section */
export interface Vrf extends BaseObject {
    table?: number;
}
/** Parses the attributes of a {@link Vrf} object */
export declare function parseVrf(r: Buffer): Vrf;
/** Encodes a {@link Vrf} object into a stream of attributes */
export declare function formatVrf(x: Vrf): StreamData;
export interface VrfPort extends BaseObject {
    table?: Buffer;
}
/** Parses the attributes of a {@link VrfPort} object */
export declare function parseVrfPort(r: Buffer): VrfPort;
/** Encodes a {@link VrfPort} object into a stream of attributes */
export declare function formatVrfPort(x: VrfPort): StreamData;
/** MACSEC section */
export interface Macsec extends BaseObject {
    sci?: bigint;
    port?: number;
    icvLen?: number;
    cipherSuite?: bigint;
    window?: number;
    encodingSa?: number;
    encrypt?: number;
    protect?: number;
    incSci?: number;
    es?: number;
    scb?: number;
    replayProtect?: number;
    validation?: number;
    __pad?: Buffer;
}
/** Parses the attributes of a {@link Macsec} object */
export declare function parseMacsec(r: Buffer): Macsec;
/** Encodes a {@link Macsec} object into a stream of attributes */
export declare function formatMacsec(x: Macsec): StreamData;
/** XFRM section */
export interface Xfrm extends BaseObject {
    link?: number;
    ifId?: number;
}
/** Parses the attributes of a {@link Xfrm} object */
export declare function parseXfrm(r: Buffer): Xfrm;
/** Encodes a {@link Xfrm} object into a stream of attributes */
export declare function formatXfrm(x: Xfrm): StreamData;
export declare enum MacsecValidationType {
    DISABLED = 0,
    CHECK = 1,
    STRICT = 2
}
export declare enum MacsecOffload {
    OFF = 0,
    PHY = 1
}
/** IPVLAN section */
export interface Ipvlan extends BaseObject {
    mode?: number;
    flags?: Buffer;
}
/** Parses the attributes of a {@link Ipvlan} object */
export declare function parseIpvlan(r: Buffer): Ipvlan;
/** Encodes a {@link Ipvlan} object into a stream of attributes */
export declare function formatIpvlan(x: Ipvlan): StreamData;
export declare enum IpvlanMode {
    L2 = 0,
    L3 = 1,
    L3S = 2
}
/** VXLAN section */
export interface Vxlan extends BaseObject {
    id?: number;
    /** group or remote address */
    group?: Buffer;
    link?: number;
    local?: Buffer;
    ttl?: number;
    tos?: number;
    learning?: number;
    ageing?: number;
    limit?: number;
    /** source port */
    portRange?: Buffer;
    proxy?: number;
    rsc?: number;
    l2miss?: number;
    l3miss?: number;
    /** destination port */
    port?: Buffer;
    group6?: Buffer;
    local6?: Buffer;
    udpCsum?: number;
    udpZeroCsum6Tx?: number;
    udpZeroCsum6Rx?: number;
    remcsumTx?: number;
    remcsumRx?: number;
    gbp?: true;
    remcsumNopartial?: Buffer;
    collectMetadata?: number;
    label?: number;
    gpe?: true;
    ttlInherit?: Buffer;
    df?: Buffer;
}
/** Parses the attributes of a {@link Vxlan} object */
export declare function parseVxlan(r: Buffer): Vxlan;
/** Encodes a {@link Vxlan} object into a stream of attributes */
export declare function formatVxlan(x: Vxlan): StreamData;
export interface VxlanPortRange {
    low?: number;
    high?: number;
}
/** Parses the attributes of a {@link VxlanPortRange} object */
export declare function parseVxlanPortRange(r: Buffer): VxlanPortRange;
/** Encodes a {@link VxlanPortRange} object into a stream of attributes */
export declare function formatVxlanPortRange(x: VxlanPortRange, r?: Buffer): Buffer;
export declare const __LENGTH_VxlanPortRange = 4;
export declare enum VxlanDf {
    UNSET = 0,
    SET = 1,
    INHERIT = 2
}
/** GENEVE section */
export interface Geneve extends BaseObject {
    id?: number;
    remote?: Buffer;
    ttl?: number;
    tos?: number;
    /** destination port */
    port?: Buffer;
    collectMetadata?: Buffer;
    remote6?: Buffer;
    udpCsum?: number;
    udpZeroCsum6Tx?: number;
    udpZeroCsum6Rx?: number;
    label?: number;
    ttlInherit?: Buffer;
    df?: Buffer;
}
/** Parses the attributes of a {@link Geneve} object */
export declare function parseGeneve(r: Buffer): Geneve;
/** Encodes a {@link Geneve} object into a stream of attributes */
export declare function formatGeneve(x: Geneve): StreamData;
export declare enum GeneveDf {
    UNSET = 0,
    SET = 1,
    INHERIT = 2
}
/** PPP section */
export interface Ppp extends BaseObject {
    devFd?: number;
}
/** Parses the attributes of a {@link Ppp} object */
export declare function parsePpp(r: Buffer): Ppp;
/** Encodes a {@link Ppp} object into a stream of attributes */
export declare function formatPpp(x: Ppp): StreamData;
/** GTP section */
export declare enum GtpRole {
    GGSN = 0,
    SGSN = 1
}
export interface Gtp extends BaseObject {
    fd0?: Buffer;
    fd1?: Buffer;
    pdpHashsize?: Buffer;
    role?: Buffer;
}
/** Parses the attributes of a {@link Gtp} object */
export declare function parseGtp(r: Buffer): Gtp;
/** Encodes a {@link Gtp} object into a stream of attributes */
export declare function formatGtp(x: Gtp): StreamData;
/** Bonding section */
export interface Bond extends BaseObject {
    mode?: Buffer;
    activeSlave?: Buffer;
    miimon?: Buffer;
    updelay?: Buffer;
    downdelay?: Buffer;
    useCarrier?: Buffer;
    arpInterval?: Buffer;
    arpIpTarget?: Buffer;
    arpValidate?: Buffer;
    arpAllTargets?: Buffer;
    primary?: Buffer;
    primaryReselect?: Buffer;
    failOverMac?: Buffer;
    xmitHashPolicy?: Buffer;
    resendIgmp?: Buffer;
    numPeerNotif?: Buffer;
    allSlavesActive?: Buffer;
    minLinks?: Buffer;
    lpInterval?: Buffer;
    packetsPerSlave?: Buffer;
    adLacpRate?: Buffer;
    adSelect?: Buffer;
    adInfo?: BondAdInfo;
    adActorSysPrio?: Buffer;
    adUserPortKey?: Buffer;
    adActorSystem?: Buffer;
    tlbDynamicLb?: Buffer;
    peerNotifDelay?: Buffer;
}
/** Parses the attributes of a {@link Bond} object */
export declare function parseBond(r: Buffer): Bond;
/** Encodes a {@link Bond} object into a stream of attributes */
export declare function formatBond(x: Bond): StreamData;
export interface BondAdInfo extends BaseObject {
    aggregator?: Buffer;
    numPorts?: Buffer;
    actorKey?: Buffer;
    partnerKey?: Buffer;
    partnerMac?: Buffer;
}
/** Parses the attributes of a {@link BondAdInfo} object */
export declare function parseBondAdInfo(r: Buffer): BondAdInfo;
/** Encodes a {@link BondAdInfo} object into a stream of attributes */
export declare function formatBondAdInfo(x: BondAdInfo): StreamData;
export interface BondSlave extends BaseObject {
    state?: Buffer;
    miiStatus?: Buffer;
    linkFailureCount?: Buffer;
    permHwaddr?: Buffer;
    queueId?: Buffer;
    adAggregatorId?: Buffer;
    adActorOperPortState?: Buffer;
    adPartnerOperPortState?: Buffer;
}
/** Parses the attributes of a {@link BondSlave} object */
export declare function parseBondSlave(r: Buffer): BondSlave;
/** Encodes a {@link BondSlave} object into a stream of attributes */
export declare function formatBondSlave(x: BondSlave): StreamData;
export interface VirtualFunctionList extends BaseObject {
    x?: VirtualFunction[];
}
/** Parses the attributes of a {@link VirtualFunctionList} object */
export declare function parseVirtualFunctionList(r: Buffer): VirtualFunctionList;
/** Encodes a {@link VirtualFunctionList} object into a stream of attributes */
export declare function formatVirtualFunctionList(x: VirtualFunctionList): StreamData;
/** SR-IOV virtual function management section */
export interface VirtualFunction extends BaseObject {
    /** Hardware queue specific attributes */
    mac?: Buffer;
    /** VLAN ID and QoS */
    vlan?: Buffer;
    /** Max TX Bandwidth Allocation */
    txRate?: Buffer;
    /** Spoof Checking on/off switch */
    spoofchk?: Buffer;
    /** link state enable/disable/auto switch */
    linkState?: Buffer;
    /** Min and Max TX Bandwidth Allocation */
    rate?: Buffer;
    rssQueryEn?: Buffer;
    /** network device statistics */
    stats?: VirtualFunctionStats;
    /** Trust VF */
    trust?: Buffer;
    /** VF Infiniband node GUID */
    ibNodeGuid?: Buffer;
    /** VF Infiniband port GUID */
    ibPortGuid?: Buffer;
    /** nested list of vlans, option for QinQ */
    vlanList?: Buffer;
    /** VF broadcast */
    broadcast?: Buffer;
}
/** Parses the attributes of a {@link VirtualFunction} object */
export declare function parseVirtualFunction(r: Buffer): VirtualFunction;
/** Encodes a {@link VirtualFunction} object into a stream of attributes */
export declare function formatVirtualFunction(x: VirtualFunction): StreamData;
export interface VirtualFunctionMac {
    vf?: number;
    /** MAX_ADDR_LEN */
    mac?: number[];
}
/** Parses the attributes of a {@link VirtualFunctionMac} object */
export declare function parseVirtualFunctionMac(r: Buffer): VirtualFunctionMac;
/** Encodes a {@link VirtualFunctionMac} object into a stream of attributes */
export declare function formatVirtualFunctionMac(x: VirtualFunctionMac, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionMac = 36;
export interface VirtualFunctionBroadcast {
    broadcast?: number[];
}
/** Parses the attributes of a {@link VirtualFunctionBroadcast} object */
export declare function parseVirtualFunctionBroadcast(r: Buffer): VirtualFunctionBroadcast;
/** Encodes a {@link VirtualFunctionBroadcast} object into a stream of attributes */
export declare function formatVirtualFunctionBroadcast(x: VirtualFunctionBroadcast, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionBroadcast = 32;
export interface VirtualFunctionVlan {
    vf?: number;
    /** 0 - 4095, 0 disables VLAN filter */
    vlan?: number;
    qos?: number;
}
/** Parses the attributes of a {@link VirtualFunctionVlan} object */
export declare function parseVirtualFunctionVlan(r: Buffer): VirtualFunctionVlan;
/** Encodes a {@link VirtualFunctionVlan} object into a stream of attributes */
export declare function formatVirtualFunctionVlan(x: VirtualFunctionVlan, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionVlan = 12;
export interface VlanList extends BaseObject {
    /** VLAN ID, QoS and VLAN protocol */
    x?: Vlan[];
}
/** Parses the attributes of a {@link VlanList} object */
export declare function parseVlanList(r: Buffer): VlanList;
/** Encodes a {@link VlanList} object into a stream of attributes */
export declare function formatVlanList(x: VlanList): StreamData;
export interface VirtualFunctionVlanInfo {
    vf?: number;
    /** 0 - 4095, 0 disables VLAN filter */
    vlan?: number;
    qos?: number;
    /** VLAN protocol either 802.1Q or 802.1ad */
    vlanProto?: number;
}
/** Parses the attributes of a {@link VirtualFunctionVlanInfo} object */
export declare function parseVirtualFunctionVlanInfo(r: Buffer): VirtualFunctionVlanInfo;
/** Encodes a {@link VirtualFunctionVlanInfo} object into a stream of attributes */
export declare function formatVirtualFunctionVlanInfo(x: VirtualFunctionVlanInfo, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionVlanInfo = 14;
export interface VirtualFunctionTxRate {
    vf?: number;
    /** Max TX bandwidth in Mbps, 0 disables throttling */
    rate?: number;
}
/** Parses the attributes of a {@link VirtualFunctionTxRate} object */
export declare function parseVirtualFunctionTxRate(r: Buffer): VirtualFunctionTxRate;
/** Encodes a {@link VirtualFunctionTxRate} object into a stream of attributes */
export declare function formatVirtualFunctionTxRate(x: VirtualFunctionTxRate, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionTxRate = 8;
export interface VirtualFunctionRate {
    vf?: number;
    /** Min Bandwidth in Mbps */
    minTxRate?: number;
    /** Max Bandwidth in Mbps */
    maxTxRate?: number;
}
/** Parses the attributes of a {@link VirtualFunctionRate} object */
export declare function parseVirtualFunctionRate(r: Buffer): VirtualFunctionRate;
/** Encodes a {@link VirtualFunctionRate} object into a stream of attributes */
export declare function formatVirtualFunctionRate(x: VirtualFunctionRate, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionRate = 12;
export interface VirtualFunctionSpoofchk {
    vf?: number;
    setting?: number;
}
/** Parses the attributes of a {@link VirtualFunctionSpoofchk} object */
export declare function parseVirtualFunctionSpoofchk(r: Buffer): VirtualFunctionSpoofchk;
/** Encodes a {@link VirtualFunctionSpoofchk} object into a stream of attributes */
export declare function formatVirtualFunctionSpoofchk(x: VirtualFunctionSpoofchk, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionSpoofchk = 8;
export interface VirtualFunctionGuid {
    vf?: number;
    guid?: bigint;
}
/** Parses the attributes of a {@link VirtualFunctionGuid} object */
export declare function parseVirtualFunctionGuid(r: Buffer): VirtualFunctionGuid;
/** Encodes a {@link VirtualFunctionGuid} object into a stream of attributes */
export declare function formatVirtualFunctionGuid(x: VirtualFunctionGuid, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionGuid = 12;
export declare enum VirtualFunctionLinkStateId {
    /** link state of the uplink */
    AUTO = 0,
    /** link always up */
    ENABLE = 1,
    /** link always down */
    DISABLE = 2
}
export interface VirtualFunctionLinkState {
    vf?: number;
    linkState?: VirtualFunctionLinkStateId | keyof typeof VirtualFunctionLinkStateId;
}
/** Parses the attributes of a {@link VirtualFunctionLinkState} object */
export declare function parseVirtualFunctionLinkState(r: Buffer): VirtualFunctionLinkState;
/** Encodes a {@link VirtualFunctionLinkState} object into a stream of attributes */
export declare function formatVirtualFunctionLinkState(x: VirtualFunctionLinkState, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionLinkState = 8;
export interface VirtualFunctionRssQueryEn {
    vf?: number;
    setting?: number;
}
/** Parses the attributes of a {@link VirtualFunctionRssQueryEn} object */
export declare function parseVirtualFunctionRssQueryEn(r: Buffer): VirtualFunctionRssQueryEn;
/** Encodes a {@link VirtualFunctionRssQueryEn} object into a stream of attributes */
export declare function formatVirtualFunctionRssQueryEn(x: VirtualFunctionRssQueryEn, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionRssQueryEn = 8;
export interface VirtualFunctionStats extends BaseObject {
    rxPackets?: Buffer;
    txPackets?: Buffer;
    rxBytes?: Buffer;
    txBytes?: Buffer;
    broadcast?: Buffer;
    multicast?: Buffer;
    __pad?: Buffer;
    rxDropped?: Buffer;
    txDropped?: Buffer;
}
/** Parses the attributes of a {@link VirtualFunctionStats} object */
export declare function parseVirtualFunctionStats(r: Buffer): VirtualFunctionStats;
/** Encodes a {@link VirtualFunctionStats} object into a stream of attributes */
export declare function formatVirtualFunctionStats(x: VirtualFunctionStats): StreamData;
export interface VirtualFunctionTrust {
    vf?: number;
    setting?: number;
}
/** Parses the attributes of a {@link VirtualFunctionTrust} object */
export declare function parseVirtualFunctionTrust(r: Buffer): VirtualFunctionTrust;
/** Encodes a {@link VirtualFunctionTrust} object into a stream of attributes */
export declare function formatVirtualFunctionTrust(x: VirtualFunctionTrust, r?: Buffer): Buffer;
export declare const __LENGTH_VirtualFunctionTrust = 8;
export interface PortList extends BaseObject {
    /** nest */
    x?: Port[];
}
/** Parses the attributes of a {@link PortList} object */
export declare function parsePortList(r: Buffer): PortList;
/** Encodes a {@link PortList} object into a stream of attributes */
export declare function formatPortList(x: PortList): StreamData;
export interface Port extends BaseObject {
    /** __u32 */
    vf?: Buffer;
    /** string */
    profile?: Buffer;
    /** 802.1Qbg (pre-)standard VDP */
    vsiType?: Buffer;
    /** binary UUID */
    instanceUuid?: Buffer;
    hostUuid?: Buffer;
    /** __u8 */
    request?: Buffer;
    /** __u16, output only */
    response?: Buffer;
}
/** Parses the attributes of a {@link Port} object */
export declare function parsePort(r: Buffer): Port;
/** Encodes a {@link Port} object into a stream of attributes */
export declare function formatPort(x: Port): StreamData;
export declare enum PortRequest {
    PREASSOCIATE = 0,
    PREASSOCIATE_RR = 1,
    ASSOCIATE = 2,
    DISASSOCIATE = 3
}
export declare enum PortVdpResponse {
    SUCCESS = 0,
    INVALID_FORMAT = 1,
    INSUFFICIENT_RESOURCES = 2,
    UNUSED_VTID = 3,
    VTID_VIOLATION = 4,
    VTID_VERSION_VIOALTION = 5,
    OUT_OF_SYNC = 6
}
export declare enum PortProfileResponse {
    /** 0x08-0xFF reserved for future VDP use */
    SUCCESS = 256,
    INPROGRESS = 257,
    INVALID = 258,
    BADSTATE = 259,
    INSUFFICIENT_RESOURCES = 260,
    ERROR = 261
}
export interface PortVsi {
    vsiMgrId?: number;
    vsiTypeId?: number[];
    vsiTypeVersion?: number;
    __pad?: number[];
}
/** Parses the attributes of a {@link PortVsi} object */
export declare function parsePortVsi(r: Buffer): PortVsi;
/** Encodes a {@link PortVsi} object into a stream of attributes */
export declare function formatPortVsi(x: PortVsi, r?: Buffer): Buffer;
export declare const __LENGTH_PortVsi = 8;
/** IPoIB section */
export interface Ipoib extends BaseObject {
    pkey?: Buffer;
    mode?: Buffer;
    umcast?: Buffer;
}
/** Parses the attributes of a {@link Ipoib} object */
export declare function parseIpoib(r: Buffer): Ipoib;
/** Encodes a {@link Ipoib} object into a stream of attributes */
export declare function formatIpoib(x: Ipoib): StreamData;
export declare enum IpoibMode {
    /** using unreliable datagram QPs */
    DATAGRAM = 0,
    /** using connected QPs */
    CONNECTED = 1
}
/** HSR section */
export interface Hsr extends BaseObject {
    slave1?: Buffer;
    slave2?: Buffer;
    /** Last byte of supervision addr */
    multicastSpec?: Buffer;
    /** Supervision frame multicast addr */
    supervisionAddr?: Buffer;
    seqNr?: Buffer;
    /** HSR version */
    version?: Buffer;
}
/** Parses the attributes of a {@link Hsr} object */
export declare function parseHsr(r: Buffer): Hsr;
/** Encodes a {@link Hsr} object into a stream of attributes */
export declare function formatHsr(x: Hsr): StreamData;
/** STATS section */
export interface IfStatsMsg {
    family?: number;
    __pad1?: number;
    __pad2?: number;
    ifindex?: number;
    filterMask?: number;
}
/** Parses the attributes of a {@link IfStatsMsg} object */
export declare function parseIfStatsMsg(r: Buffer): IfStatsMsg;
/** Encodes a {@link IfStatsMsg} object into a stream of attributes */
export declare function formatIfStatsMsg(x: IfStatsMsg, r?: Buffer): Buffer;
export declare const __LENGTH_IfStatsMsg = 12;
export interface Stats extends BaseObject {
    link64?: Buffer;
    linkXstats?: Xstats;
    linkXstatsSlave?: Xstats;
    linkOffloadXstats?: OffloadXstats;
    afSpec?: Map<number, Buffer>;
}
/** Parses the attributes of a {@link Stats} object */
export declare function parseStats(r: Buffer): Stats;
/** Encodes a {@link Stats} object into a stream of attributes */
export declare function formatStats(x: Stats): StreamData;
export interface Xstats extends BaseObject {
    bridge?: BridgeXstats;
    bond?: Buffer;
}
/** Parses the attributes of a {@link Xstats} object */
export declare function parseXstats(r: Buffer): Xstats;
/** Encodes a {@link Xstats} object into a stream of attributes */
export declare function formatXstats(x: Xstats): StreamData;
/** These are stats embedded into IFLA_STATS_LINK_OFFLOAD_XSTATS */
export interface OffloadXstats extends BaseObject {
    /** struct rtnl_link_stats64 */
    cpuHit?: LinkStats64;
}
/** Parses the attributes of a {@link OffloadXstats} object */
export declare function parseOffloadXstats(r: Buffer): OffloadXstats;
/** Encodes a {@link OffloadXstats} object into a stream of attributes */
export declare function formatOffloadXstats(x: OffloadXstats): StreamData;
/** XDP section */
export interface XdpFlags {
    updateIfNoexist?: true;
    skbMode?: true;
    drvMode?: true;
    hwMode?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link XdpFlags} bitmask */
export declare function parseXdpFlags(r: number): XdpFlags;
/** Encodes a {@link XdpFlags} bitmask */
export declare function formatXdpFlags(x: XdpFlags): number;
/** These are stored into IFLA_XDP_ATTACHED on dump. */
export declare enum XdpAttached {
    NONE = 0,
    DRV = 1,
    SKB = 2,
    HW = 3,
    MULTI = 4
}
export interface Xdp extends BaseObject {
    fd?: Buffer;
    attached?: XdpAttached | keyof typeof XdpAttached;
    flags?: Buffer;
    progId?: Buffer;
    drvProgId?: Buffer;
    skbProgId?: Buffer;
    hwProgId?: Buffer;
}
/** Parses the attributes of a {@link Xdp} object */
export declare function parseXdp(r: Buffer): Xdp;
/** Encodes a {@link Xdp} object into a stream of attributes */
export declare function formatXdp(x: Xdp): StreamData;
export declare enum Event {
    NONE = 0,
    /** internal reset / reboot */
    REBOOT = 1,
    /** change in offload features */
    FEATURES = 2,
    /** change in active slave */
    BONDING_FAILOVER = 3,
    /** re-sent grat. arp/ndisc */
    NOTIFY_PEERS = 4,
    /** re-sent IGMP JOIN */
    IGMP_RESEND = 5,
    /** change in bonding options */
    BONDING_OPTIONS = 6
}
/** tun section */
export interface Tun extends BaseObject {
    owner?: Buffer;
    group?: Buffer;
    type?: Buffer;
    pi?: Buffer;
    vnetHdr?: Buffer;
    persist?: Buffer;
    multiQueue?: Buffer;
    numQueues?: Buffer;
    numDisabledQueues?: Buffer;
}
/** Parses the attributes of a {@link Tun} object */
export declare function parseTun(r: Buffer): Tun;
/** Encodes a {@link Tun} object into a stream of attributes */
export declare function formatTun(x: Tun): StreamData;
/** rmnet section */
export interface RmnetFlags {
    ingressDeaggregation?: true;
    ingressMapCommands?: true;
    ingressMapCksumv4?: true;
    egressMapCksumv4?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link RmnetFlags} bitmask */
export declare function parseRmnetFlags(r: number): RmnetFlags;
/** Encodes a {@link RmnetFlags} bitmask */
export declare function formatRmnetFlags(x: RmnetFlags): number;
export interface Rmnet extends BaseObject {
    muxId?: Buffer;
    flags?: Buffer;
}
/** Parses the attributes of a {@link Rmnet} object */
export declare function parseRmnet(r: Buffer): Rmnet;
/** Encodes a {@link Rmnet} object into a stream of attributes */
export declare function formatRmnet(x: Rmnet): StreamData;
export interface RmnetFlagsMask {
    flags?: RmnetFlags;
    mask?: RmnetFlags;
}
/** Parses the attributes of a {@link RmnetFlagsMask} object */
export declare function parseRmnetFlagsMask(r: Buffer): RmnetFlagsMask;
/** Encodes a {@link RmnetFlagsMask} object into a stream of attributes */
export declare function formatRmnetFlagsMask(x: RmnetFlagsMask, r?: Buffer): Buffer;
export declare const __LENGTH_RmnetFlagsMask = 8;
export interface VethInfo extends BaseObject {
    peer?: Buffer;
}
/** Parses the attributes of a {@link VethInfo} object */
export declare function parseVethInfo(r: Buffer): VethInfo;
/** Encodes a {@link VethInfo} object into a stream of attributes */
export declare function formatVethInfo(x: VethInfo): StreamData;
export interface VlanFlags {
    reorderHdr?: true;
    gvrp?: true;
    looseBinding?: true;
    mvrp?: true;
    bridgeBinding?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link VlanFlags} bitmask */
export declare function parseVlanFlags(r: number): VlanFlags;
/** Encodes a {@link VlanFlags} bitmask */
export declare function formatVlanFlags(x: VlanFlags): number;
export declare enum VlanNameType {
    /** Name will look like:  vlan0005 */
    PLUS_VID = 0,
    /** name will look like:  eth1.0005 */
    RAW_PLUS_VID = 1,
    /** Name will look like:  vlan5 */
    PLUS_VID_NO_PAD = 2,
    /** Name will look like:  eth0.5 */
    RAW_PLUS_VID_NO_PAD = 3
}
export declare enum BridgeState {
    DISABLED = 0,
    LISTENING = 1,
    LEARNING = 2,
    FORWARDING = 3,
    BLOCKING = 4
}
/** Bridge Flags */
export interface BridgeFlags {
    /** Bridge command to/from master */
    master?: true;
    /** Bridge command to/from lowerdev */
    self?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link BridgeFlags} bitmask */
export declare function parseBridgeFlags(r: number): BridgeFlags;
/** Encodes a {@link BridgeFlags} bitmask */
export declare function formatBridgeFlags(x: BridgeFlags): number;
export declare enum BridgeMode {
    /** Default loopback mode */
    VEB = 0,
    /** 802.1Qbg defined VEPA mode */
    VEPA = 1,
    /** mode undefined */
    UNDEF = 65535
}
export interface BridgeSpec extends BaseObject {
    flags?: number;
    mode?: number;
    vlanInfo?: Buffer;
    vlanTunnelInfo?: Buffer;
}
/** Parses the attributes of a {@link BridgeSpec} object */
export declare function parseBridgeSpec(r: Buffer): BridgeSpec;
/** Encodes a {@link BridgeSpec} object into a stream of attributes */
export declare function formatBridgeSpec(x: BridgeSpec): StreamData;
export interface BridgeVlanFlags {
    /** Operate on Bridge device as well */
    master?: true;
    /** VLAN is PVID, ingress untagged */
    pvid?: true;
    /** VLAN egresses untagged */
    untagged?: true;
    /** VLAN is start of vlan range */
    rangeBegin?: true;
    /** VLAN is end of vlan range */
    rangeEnd?: true;
    /** Global bridge VLAN entry */
    brentry?: true;
    /** Skip create/delete/flags */
    onlyOpts?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link BridgeVlanFlags} bitmask */
export declare function parseBridgeVlanFlags(r: number): BridgeVlanFlags;
/** Encodes a {@link BridgeVlanFlags} bitmask */
export declare function formatBridgeVlanFlags(x: BridgeVlanFlags): number;
export interface BridgeVlanInfo {
    flags?: number;
    vid?: number;
}
/** Parses the attributes of a {@link BridgeVlanInfo} object */
export declare function parseBridgeVlanInfo(r: Buffer): BridgeVlanInfo;
/** Encodes a {@link BridgeVlanInfo} object into a stream of attributes */
export declare function formatBridgeVlanInfo(x: BridgeVlanInfo, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeVlanInfo = 4;
export interface BridgeVlanTunnel extends BaseObject {
    id?: Buffer;
    vid?: Buffer;
    flags?: Buffer;
}
/** Parses the attributes of a {@link BridgeVlanTunnel} object */
export declare function parseBridgeVlanTunnel(r: Buffer): BridgeVlanTunnel;
/** Encodes a {@link BridgeVlanTunnel} object into a stream of attributes */
export declare function formatBridgeVlanTunnel(x: BridgeVlanTunnel): StreamData;
export interface BridgeVlanXstats {
    rxBytes?: bigint;
    rxPackets?: bigint;
    txBytes?: bigint;
    txPackets?: bigint;
    vid?: number;
    flags?: number;
    __pad2?: number;
}
/** Parses the attributes of a {@link BridgeVlanXstats} object */
export declare function parseBridgeVlanXstats(r: Buffer): BridgeVlanXstats;
/** Encodes a {@link BridgeVlanXstats} object into a stream of attributes */
export declare function formatBridgeVlanXstats(x: BridgeVlanXstats, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeVlanXstats = 40;
export interface BridgeStpXstats {
    transitionBlk?: bigint;
    transitionFwd?: bigint;
    rxBpdu?: bigint;
    txBpdu?: bigint;
    rxTcn?: bigint;
    txTcn?: bigint;
}
/** Parses the attributes of a {@link BridgeStpXstats} object */
export declare function parseBridgeStpXstats(r: Buffer): BridgeStpXstats;
/** Encodes a {@link BridgeStpXstats} object into a stream of attributes */
export declare function formatBridgeStpXstats(x: BridgeStpXstats, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeStpXstats = 48;
/** Bridge vlan RTM header */
export interface BridgeVlanMsg {
    family?: number;
    __reserved1?: number;
    __reserved2?: number;
    ifindex?: number;
}
/** Parses the attributes of a {@link BridgeVlanMsg} object */
export declare function parseBridgeVlanMsg(r: Buffer): BridgeVlanMsg;
/** Encodes a {@link BridgeVlanMsg} object into a stream of attributes */
export declare function formatBridgeVlanMsg(x: BridgeVlanMsg, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeVlanMsg = 8;
export interface BridgeVlanDb extends BaseObject {
    entry?: BridgeVlanDbEntry;
}
/** Parses the attributes of a {@link BridgeVlanDb} object */
export declare function parseBridgeVlanDb(r: Buffer): BridgeVlanDb;
/** Encodes a {@link BridgeVlanDb} object into a stream of attributes */
export declare function formatBridgeVlanDb(x: BridgeVlanDb): StreamData;
export interface BridgeVlanDbEntry extends BaseObject {
    info?: Buffer;
    range?: Buffer;
    state?: Buffer;
}
/** Parses the attributes of a {@link BridgeVlanDbEntry} object */
export declare function parseBridgeVlanDbEntry(r: Buffer): BridgeVlanDbEntry;
/** Encodes a {@link BridgeVlanDbEntry} object into a stream of attributes */
export declare function formatBridgeVlanDbEntry(x: BridgeVlanDbEntry): StreamData;
export interface Mdba extends BaseObject {
    mdb?: MdbaMdb;
    router?: MdbaRouter;
}
/** Parses the attributes of a {@link Mdba} object */
export declare function parseMdba(r: Buffer): Mdba;
/** Encodes a {@link Mdba} object into a stream of attributes */
export declare function formatMdba(x: Mdba): StreamData;
export interface MdbaMdb extends BaseObject {
    entry?: MdbaMdbEntry;
}
/** Parses the attributes of a {@link MdbaMdb} object */
export declare function parseMdbaMdb(r: Buffer): MdbaMdb;
/** Encodes a {@link MdbaMdb} object into a stream of attributes */
export declare function formatMdbaMdb(x: MdbaMdb): StreamData;
export interface MdbaMdbEntry extends BaseObject {
    info?: Buffer;
}
/** Parses the attributes of a {@link MdbaMdbEntry} object */
export declare function parseMdbaMdbEntry(r: Buffer): MdbaMdbEntry;
/** Encodes a {@link MdbaMdbEntry} object into a stream of attributes */
export declare function formatMdbaMdbEntry(x: MdbaMdbEntry): StreamData;
/** per mdb entry additional attributes */
export interface MdbaMdbEattr extends BaseObject {
    timer?: Buffer;
}
/** Parses the attributes of a {@link MdbaMdbEattr} object */
export declare function parseMdbaMdbEattr(r: Buffer): MdbaMdbEattr;
/** Encodes a {@link MdbaMdbEattr} object into a stream of attributes */
export declare function formatMdbaMdbEattr(x: MdbaMdbEattr): StreamData;
/** multicast router types */
export declare enum MdbRtrType {
    DISABLED = 0,
    TEMP_QUERY = 1,
    PERM = 2,
    TEMP = 3
}
export interface MdbaRouter extends BaseObject {
    port?: Buffer;
}
/** Parses the attributes of a {@link MdbaRouter} object */
export declare function parseMdbaRouter(r: Buffer): MdbaRouter;
/** Encodes a {@link MdbaRouter} object into a stream of attributes */
export declare function formatMdbaRouter(x: MdbaRouter): StreamData;
/** router port attributes */
export interface MdbaRouterPattr extends BaseObject {
    timer?: Buffer;
    type?: Buffer;
}
/** Parses the attributes of a {@link MdbaRouterPattr} object */
export declare function parseMdbaRouterPattr(r: Buffer): MdbaRouterPattr;
/** Encodes a {@link MdbaRouterPattr} object into a stream of attributes */
export declare function formatMdbaRouterPattr(x: MdbaRouterPattr): StreamData;
export interface BridgePortMsg {
    family?: number;
    ifindex?: number;
}
/** Parses the attributes of a {@link BridgePortMsg} object */
export declare function parseBridgePortMsg(r: Buffer): BridgePortMsg;
/** Encodes a {@link BridgePortMsg} object into a stream of attributes */
export declare function formatBridgePortMsg(x: BridgePortMsg, r?: Buffer): Buffer;
export declare const __LENGTH_BridgePortMsg = 5;
export interface _IpWithProto {
    /** IPv6 or IPv4 in network order */
    ip?: Buffer;
    proto?: number;
}
/** Parses the attributes of a {@link _IpWithProto} object */
export declare function parse_IpWithProto(r: Buffer): _IpWithProto;
/** Encodes a {@link _IpWithProto} object into a stream of attributes */
export declare function format_IpWithProto(x: _IpWithProto, r?: Buffer): Buffer;
export declare const __LENGTH__IpWithProto = 18;
export interface BridgeMdbEntry {
    ifindex?: number;
    state?: number;
    flags?: number;
    vid?: number;
    addr?: _IpWithProto;
}
/** Parses the attributes of a {@link BridgeMdbEntry} object */
export declare function parseBridgeMdbEntry(r: Buffer): BridgeMdbEntry;
/** Encodes a {@link BridgeMdbEntry} object into a stream of attributes */
export declare function formatBridgeMdbEntry(x: BridgeMdbEntry, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeMdbEntry: number;
export declare enum BridgeMdbState {
    TEMPORARY = 0,
    PERMANENT = 1
}
export interface MdbFlags {
    offload?: true;
    fastLeave?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link MdbFlags} bitmask */
export declare function parseMdbFlags(r: number): MdbFlags;
/** Encodes a {@link MdbFlags} bitmask */
export declare function formatMdbFlags(x: MdbFlags): number;
export interface MdbaSetEntry extends BaseObject {
    x?: MdbaSetEntry[];
}
/** Parses the attributes of a {@link MdbaSetEntry} object */
export declare function parseMdbaSetEntry(r: Buffer): MdbaSetEntry;
/** Encodes a {@link MdbaSetEntry} object into a stream of attributes */
export declare function formatMdbaSetEntry(x: MdbaSetEntry): StreamData;
/** Embedded inside LINK_XSTATS_TYPE_BRIDGE */
export interface BridgeXstats extends BaseObject {
    vlan?: Buffer;
    mcast?: Buffer;
    __pad?: Buffer;
    stp?: Buffer;
}
/** Parses the attributes of a {@link BridgeXstats} object */
export declare function parseBridgeXstats(r: Buffer): BridgeXstats;
/** Encodes a {@link BridgeXstats} object into a stream of attributes */
export declare function formatBridgeXstats(x: BridgeXstats): StreamData;
export declare enum BridgeMcastDir {
    RX = 0,
    TX = 1
}
/** IGMP/MLD statistics */
export interface BridgeMcastStats {
    /** BR_MCAST_DIR_SIZE */
    igmpV1queries?: bigint[];
    igmpV2queries?: bigint[];
    igmpV3queries?: bigint[];
    igmpLeaves?: bigint[];
    igmpV1reports?: bigint[];
    igmpV2reports?: bigint[];
    igmpV3reports?: bigint[];
    igmpParseErrors?: bigint;
    mldV1queries?: bigint[];
    mldV2queries?: bigint[];
    mldLeaves?: bigint[];
    mldV1reports?: bigint[];
    mldV2reports?: bigint[];
    mldParseErrors?: bigint;
    mcastBytes?: bigint[];
    mcastPackets?: bigint[];
}
/** Parses the attributes of a {@link BridgeMcastStats} object */
export declare function parseBridgeMcastStats(r: Buffer): BridgeMcastStats;
/** Encodes a {@link BridgeMcastStats} object into a stream of attributes */
export declare function formatBridgeMcastStats(x: BridgeMcastStats, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeMcastStats = 240;
export declare enum BridgeBooloptId {
    NO_LL_LEARN = 0
}
export interface BridgeBooloptMask {
    flags?: number;
    mask?: number;
}
/** Parses the attributes of a {@link BridgeBooloptMask} object */
export declare function parseBridgeBooloptMask(r: Buffer): BridgeBooloptMask;
/** Encodes a {@link BridgeBooloptMask} object into a stream of attributes */
export declare function formatBridgeBooloptMask(x: BridgeBooloptMask, r?: Buffer): Buffer;
export declare const __LENGTH_BridgeBooloptMask = 8;
export interface Iptun extends BaseObject {
    link?: number;
    local?: number;
    remote?: number;
    ttl?: number;
    tos?: number;
    encapLimit?: number;
    flowinfo?: number;
    flags?: Buffer;
    proto?: number;
    pmtudisc?: number;
    _6rdPrefix?: Buffer;
    _6rdRelayPrefix?: number;
    _6rdPrefixlen?: number;
    _6rdRelayPrefixlen?: number;
    encapType?: Buffer;
    encapFlags?: Buffer;
    encapSport?: Buffer;
    encapDport?: Buffer;
    collectMetadata?: Buffer;
    fwmark?: Buffer;
}
/** Parses the attributes of a {@link Iptun} object */
export declare function parseIptun(r: Buffer): Iptun;
/** Encodes a {@link Iptun} object into a stream of attributes */
export declare function formatIptun(x: Iptun): StreamData;
export declare enum TunnelEncapTypes {
    NONE = 0,
    FOU = 1,
    GUE = 2,
    MPLS = 3
}
export interface TunnelEncapFlag {
    csum?: true;
    csum6?: true;
    remcsum?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link TunnelEncapFlag} bitmask */
export declare function parseTunnelEncapFlag(r: number): TunnelEncapFlag;
/** Encodes a {@link TunnelEncapFlag} bitmask */
export declare function formatTunnelEncapFlag(x: TunnelEncapFlag): number;
export interface IpTunnelPrl {
    addr?: number;
    flags?: number;
    __reserved?: number;
    datalen?: number;
    __reserved2?: number;
}
/** Parses the attributes of a {@link IpTunnelPrl} object */
export declare function parseIpTunnelPrl(r: Buffer): IpTunnelPrl;
/** Encodes a {@link IpTunnelPrl} object into a stream of attributes */
export declare function formatIpTunnelPrl(x: IpTunnelPrl, r?: Buffer): Buffer;
export declare const __LENGTH_IpTunnelPrl = 16;
export interface IpTunnel6rd {
    /** IPv6 address, network order */
    prefix?: Buffer;
    relayPrefix?: number;
    prefixlen?: number;
    relayPrefixlen?: number;
}
/** Parses the attributes of a {@link IpTunnel6rd} object */
export declare function parseIpTunnel6rd(r: Buffer): IpTunnel6rd;
/** Encodes a {@link IpTunnel6rd} object into a stream of attributes */
export declare function formatIpTunnel6rd(x: IpTunnel6rd, r?: Buffer): Buffer;
export declare const __LENGTH_IpTunnel6rd = 24;
export interface Gre extends BaseObject {
    link?: number;
    iflags?: number;
    oflags?: number;
    ikey?: number;
    okey?: number;
    local?: number;
    remote?: number;
    ttl?: number;
    tos?: number;
    pmtudisc?: number;
    encapLimit?: Buffer;
    flowinfo?: Buffer;
    flags?: Buffer;
    encapType?: Buffer;
    encapFlags?: Buffer;
    encapSport?: Buffer;
    encapDport?: Buffer;
    collectMetadata?: Buffer;
    ignoreDf?: Buffer;
    fwmark?: Buffer;
    erspanIndex?: Buffer;
    erspanVer?: Buffer;
    erspanDir?: Buffer;
    erspanHwid?: Buffer;
}
/** Parses the attributes of a {@link Gre} object */
export declare function parseGre(r: Buffer): Gre;
/** Encodes a {@link Gre} object into a stream of attributes */
export declare function formatGre(x: Gre): StreamData;
export interface Vti extends BaseObject {
    link?: number;
    ikey?: number;
    okey?: number;
    local?: number;
    remote?: number;
    fwmark?: Buffer;
}
/** Parses the attributes of a {@link Vti} object */
export declare function parseVti(r: Buffer): Vti;
/** Encodes a {@link Vti} object into a stream of attributes */
export declare function formatVti(x: Vti): StreamData;
/** WARNING: These flags should be interpreted in big endian */
export interface Tunnel {
    csum?: true;
    routing?: true;
    key?: true;
    seq?: true;
    strict?: true;
    rec?: true;
    version?: true;
    noKey?: true;
    dontFragment?: true;
    oam?: true;
    critOpt?: true;
    geneveOpt?: true;
    vxlanOpt?: true;
    nocache?: true;
    erspanOpt?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link Tunnel} bitmask */
export declare function parseTunnel(r: number): Tunnel;
/** Encodes a {@link Tunnel} bitmask */
export declare function formatTunnel(x: Tunnel): number;
/**
 * CAN bit-timing parameters
 *
 * For further information, please read chapter "8 BIT TIMING
 * REQUIREMENTS" of the "Bosch CAN Specification version 2.0"
 * at http://www.semiconductors.bosch.de/pdf/can2spec.pdf.
 */
export interface CanBittiming {
    /** Bit-rate in bits/second */
    bitrate?: number;
    /** Sample point in one-tenth of a percent */
    samplePoint?: number;
    /** Time quanta (TQ) in nanoseconds */
    tq?: number;
    /** Propagation segment in TQs */
    propSeg?: number;
    /** Phase buffer segment 1 in TQs */
    phaseSeg1?: number;
    /** Phase buffer segment 2 in TQs */
    phaseSeg2?: number;
    /** Synchronisation jump width in TQs */
    sjw?: number;
    /** Bit-rate prescaler */
    brp?: number;
}
/** Parses the attributes of a {@link CanBittiming} object */
export declare function parseCanBittiming(r: Buffer): CanBittiming;
/** Encodes a {@link CanBittiming} object into a stream of attributes */
export declare function formatCanBittiming(x: CanBittiming, r?: Buffer): Buffer;
export declare const __LENGTH_CanBittiming = 32;
/**
 * CAN hardware-dependent bit-timing constant
 *
 * Used for calculating and checking bit-timing parameters
 */
export interface CanBittimingConst {
    /** Name of the CAN controller hardware */
    name?: number[];
    /** Time segment 1 = prop_seg + phase_seg1 */
    tseg1Min?: number;
    tseg1Max?: number;
    /** Time segment 2 = phase_seg2 */
    tseg2Min?: number;
    tseg2Max?: number;
    /** Synchronisation jump width */
    sjwMax?: number;
    /** Bit-rate prescaler */
    brpMin?: number;
    brpMax?: number;
    brpInc?: number;
}
/** Parses the attributes of a {@link CanBittimingConst} object */
export declare function parseCanBittimingConst(r: Buffer): CanBittimingConst;
/** Encodes a {@link CanBittimingConst} object into a stream of attributes */
export declare function formatCanBittimingConst(x: CanBittimingConst, r?: Buffer): Buffer;
export declare const __LENGTH_CanBittimingConst = 48;
/** CAN clock parameters */
export interface CanClock {
    /** CAN system clock frequency in Hz */
    freq?: number;
}
/** Parses the attributes of a {@link CanClock} object */
export declare function parseCanClock(r: Buffer): CanClock;
/** Encodes a {@link CanClock} object into a stream of attributes */
export declare function formatCanClock(x: CanClock, r?: Buffer): Buffer;
export declare const __LENGTH_CanClock = 4;
/** CAN operational and error states */
export declare enum CanState {
    /** RX/TX error count < 96 */
    ERROR_ACTIVE = 0,
    /** RX/TX error count < 128 */
    ERROR_WARNING = 1,
    /** RX/TX error count < 256 */
    ERROR_PASSIVE = 2,
    /** RX/TX error count >= 256 */
    BUS_OFF = 3,
    /** Device is stopped */
    STOPPED = 4,
    /** Device is sleeping */
    SLEEPING = 5
}
/** CAN bus error counters */
export interface CanBerrCounter {
    txerr?: number;
    rxerr?: number;
}
/** Parses the attributes of a {@link CanBerrCounter} object */
export declare function parseCanBerrCounter(r: Buffer): CanBerrCounter;
/** Encodes a {@link CanBerrCounter} object into a stream of attributes */
export declare function formatCanBerrCounter(x: CanBerrCounter, r?: Buffer): Buffer;
export declare const __LENGTH_CanBerrCounter = 4;
/** CAN controller mode */
export interface CanCtrlModeMask {
    mask?: CanCtrlMode;
    flags?: CanCtrlMode;
}
/** Parses the attributes of a {@link CanCtrlModeMask} object */
export declare function parseCanCtrlModeMask(r: Buffer): CanCtrlModeMask;
/** Encodes a {@link CanCtrlModeMask} object into a stream of attributes */
export declare function formatCanCtrlModeMask(x: CanCtrlModeMask, r?: Buffer): Buffer;
export declare const __LENGTH_CanCtrlModeMask = 8;
export interface CanCtrlMode {
    /** Loopback mode */
    loopback?: true;
    /** Listen-only mode */
    listenonly?: true;
    /** Triple sampling mode */
    _3Samples?: true;
    /** One-Shot mode */
    oneShot?: true;
    /** Bus-error reporting */
    berrReporting?: true;
    /** CAN FD mode */
    fd?: true;
    /** Ignore missing CAN ACKs */
    presumeAck?: true;
    /** CAN FD in non-ISO mode */
    fdNonIso?: true;
    __unknown?: number;
}
/** Parses the flags in a {@link CanCtrlMode} bitmask */
export declare function parseCanCtrlMode(r: number): CanCtrlMode;
/** Encodes a {@link CanCtrlMode} bitmask */
export declare function formatCanCtrlMode(x: CanCtrlMode): number;
/** CAN device statistics */
export interface CanDeviceStats {
    /** Bus errors */
    busError?: number;
    /** Changes to error warning state */
    errorWarning?: number;
    /** Changes to error passive state */
    errorPassive?: number;
    /** Changes to bus off state */
    busOff?: number;
    /** Arbitration lost errors */
    arbitrationLost?: number;
    /** CAN controller re-starts */
    restarts?: number;
}
/** Parses the attributes of a {@link CanDeviceStats} object */
export declare function parseCanDeviceStats(r: Buffer): CanDeviceStats;
/** Encodes a {@link CanDeviceStats} object into a stream of attributes */
export declare function formatCanDeviceStats(x: CanDeviceStats, r?: Buffer): Buffer;
export declare const __LENGTH_CanDeviceStats = 24;
/** CAN netlink interface */
export interface Can extends BaseObject {
    bittiming?: Buffer;
    bittimingConst?: Buffer;
    clock?: Buffer;
    state?: number;
    ctrlmode?: Buffer;
    restartMs?: number;
    restart?: number;
    berrCounter?: Buffer;
    dataBittiming?: Buffer;
    dataBittimingConst?: Buffer;
    termination?: Buffer;
    terminationConst?: Buffer;
    bitrateConst?: Buffer;
    dataBitrateConst?: Buffer;
    bitrateMax?: Buffer;
}
/** Parses the attributes of a {@link Can} object */
export declare function parseCan(r: Buffer): Can;
/** Encodes a {@link Can} object into a stream of attributes */
export declare function formatCan(x: Can): StreamData;