sflow_parser/models/

record_counters.rs

//! Counter record data structures
//!
//! These represent interface and system statistics collected periodically.
//! Enterprise = 0 (sFlow.org standard formats)

/// Generic Interface Counters - Format (0,1)
///
/// Standard interface statistics (RFC 2233)
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* Generic Interface Counters - see RFC 2233 */
/// /* opaque = counter_data; enterprise = 0; format = 1 */
///
/// struct if_counters {
///     unsigned int ifIndex;
///     unsigned int ifType;
///     unsigned hyper ifSpeed;
///     unsigned int ifDirection;
///     unsigned int ifStatus;
///     unsigned hyper ifInOctets;
///     unsigned int ifInUcastPkts;
///     unsigned int ifInMulticastPkts;
///     unsigned int ifInBroadcastPkts;
///     unsigned int ifInDiscards;
///     unsigned int ifInErrors;
///     unsigned int ifInUnknownProtos;
///     unsigned hyper ifOutOctets;
///     unsigned int ifOutUcastPkts;
///     unsigned int ifOutMulticastPkts;
///     unsigned int ifOutBroadcastPkts;
///     unsigned int ifOutDiscards;
///     unsigned int ifOutErrors;
///     unsigned int ifPromiscuousMode;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GenericInterfaceCounters {
    /// Interface index
    pub if_index: u32,

    /// Interface type (from IANAifType)
    pub if_type: u32,

    /// Interface speed in bits per second
    pub if_speed: u64,

    /// Interface direction (1=full-duplex, 2=half-duplex, 3=in, 4=out)
    pub if_direction: u32,

    /// Interface status (bit 0=admin, bit 1=oper)
    pub if_status: u32,

    /// Total octets received
    pub if_in_octets: u64,

    /// Total unicast packets received
    pub if_in_ucast_pkts: u32,

    /// Total multicast packets received
    pub if_in_multicast_pkts: u32,

    /// Total broadcast packets received
    pub if_in_broadcast_pkts: u32,

    /// Total discarded inbound packets
    pub if_in_discards: u32,

    /// Total inbound errors
    pub if_in_errors: u32,

    /// Total inbound packets with unknown protocol
    pub if_in_unknown_protos: u32,

    /// Total octets transmitted
    pub if_out_octets: u64,

    /// Total unicast packets transmitted
    pub if_out_ucast_pkts: u32,

    /// Total multicast packets transmitted
    pub if_out_multicast_pkts: u32,

    /// Total broadcast packets transmitted
    pub if_out_broadcast_pkts: u32,

    /// Total discarded outbound packets
    pub if_out_discards: u32,

    /// Total outbound errors
    pub if_out_errors: u32,

    /// Promiscuous mode (1=true, 2=false)
    pub if_promiscuous_mode: u32,
}

/// Ethernet Interface Counters - Format (0,2)
///
/// Ethernet-specific statistics (RFC 2358)
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* Ethernet Interface Counters - see RFC 2358 */
/// /* opaque = counter_data; enterprise = 0; format = 2 */
///
/// struct ethernet_counters {
///     unsigned int dot3StatsAlignmentErrors;
///     unsigned int dot3StatsFCSErrors;
///     unsigned int dot3StatsSingleCollisionFrames;
///     unsigned int dot3StatsMultipleCollisionFrames;
///     unsigned int dot3StatsSQETestErrors;
///     unsigned int dot3StatsDeferredTransmissions;
///     unsigned int dot3StatsLateCollisions;
///     unsigned int dot3StatsExcessiveCollisions;
///     unsigned int dot3StatsInternalMacTransmitErrors;
///     unsigned int dot3StatsCarrierSenseErrors;
///     unsigned int dot3StatsFrameTooLongs;
///     unsigned int dot3StatsInternalMacReceiveErrors;
///     unsigned int dot3StatsSymbolErrors;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EthernetInterfaceCounters {
    /// Alignment errors
    pub dot3_stats_alignment_errors: u32,

    /// FCS errors
    pub dot3_stats_fcs_errors: u32,

    /// Single collision frames
    pub dot3_stats_single_collision_frames: u32,

    /// Multiple collision frames
    pub dot3_stats_multiple_collision_frames: u32,

    /// SQE test errors
    pub dot3_stats_sqe_test_errors: u32,

    /// Deferred transmissions
    pub dot3_stats_deferred_transmissions: u32,

    /// Late collisions
    pub dot3_stats_late_collisions: u32,

    /// Excessive collisions
    pub dot3_stats_excessive_collisions: u32,

    /// Internal MAC transmit errors
    pub dot3_stats_internal_mac_transmit_errors: u32,

    /// Carrier sense errors
    pub dot3_stats_carrier_sense_errors: u32,

    /// Frame too long errors
    pub dot3_stats_frame_too_longs: u32,

    /// Internal MAC receive errors
    pub dot3_stats_internal_mac_receive_errors: u32,

    /// Symbol errors
    pub dot3_stats_symbol_errors: u32,
}

/// Token Ring Counters - Format (0,3)
///
/// Token Ring statistics (RFC 1748)
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* Token Ring Counters - see RFC 1748 */
/// /* opaque = counter_data; enterprise = 0; format = 3 */
///
/// struct tokenring_counters {
///     unsigned int dot5StatsLineErrors;
///     unsigned int dot5StatsBurstErrors;
///     unsigned int dot5StatsACErrors;
///     unsigned int dot5StatsAbortTransErrors;
///     unsigned int dot5StatsInternalErrors;
///     unsigned int dot5StatsLostFrameErrors;
///     unsigned int dot5StatsReceiveCongestions;
///     unsigned int dot5StatsFrameCopiedErrors;
///     unsigned int dot5StatsTokenErrors;
///     unsigned int dot5StatsSoftErrors;
///     unsigned int dot5StatsHardErrors;
///     unsigned int dot5StatsSignalLoss;
///     unsigned int dot5StatsTransmitBeacons;
///     unsigned int dot5StatsRecoverys;
///     unsigned int dot5StatsLobeWires;
///     unsigned int dot5StatsRemoves;
///     unsigned int dot5StatsSingles;
///     unsigned int dot5StatsFreqErrors;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TokenRingCounters {
    pub dot5_stats_line_errors: u32,
    pub dot5_stats_burst_errors: u32,
    pub dot5_stats_ac_errors: u32,
    pub dot5_stats_abort_trans_errors: u32,
    pub dot5_stats_internal_errors: u32,
    pub dot5_stats_lost_frame_errors: u32,
    pub dot5_stats_receive_congestions: u32,
    pub dot5_stats_frame_copied_errors: u32,
    pub dot5_stats_token_errors: u32,
    pub dot5_stats_soft_errors: u32,
    pub dot5_stats_hard_errors: u32,
    pub dot5_stats_signal_loss: u32,
    pub dot5_stats_transmit_beacons: u32,
    pub dot5_stats_recoverys: u32,
    pub dot5_stats_lobe_wires: u32,
    pub dot5_stats_removes: u32,
    pub dot5_stats_singles: u32,
    pub dot5_stats_freq_errors: u32,
}

/// 100BaseVG Interface Counters - Format (0,4)
///
/// 100BaseVG statistics (RFC 2020)
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* 100 BaseVG interface counters - see RFC 2020 */
/// /* opaque = counter_data; enterprise = 0; format = 4 */
///
/// struct vg_counters {
///     unsigned int dot12InHighPriorityFrames;
///     unsigned hyper dot12InHighPriorityOctets;
///     unsigned int dot12InNormPriorityFrames;
///     unsigned hyper dot12InNormPriorityOctets;
///     unsigned int dot12InIPMErrors;
///     unsigned int dot12InOversizeFrameErrors;
///     unsigned int dot12InDataErrors;
///     unsigned int dot12InNullAddressedFrames;
///     unsigned int dot12OutHighPriorityFrames;
///     unsigned hyper dot12OutHighPriorityOctets;
///     unsigned int dot12TransitionIntoTrainings;
///     unsigned hyper dot12HCInHighPriorityOctets;
///     unsigned hyper dot12HCInNormPriorityOctets;
///     unsigned hyper dot12HCOutHighPriorityOctets;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Vg100InterfaceCounters {
    pub dot12_in_high_priority_frames: u32,
    pub dot12_in_high_priority_octets: u64,
    pub dot12_in_norm_priority_frames: u32,
    pub dot12_in_norm_priority_octets: u64,
    pub dot12_in_ipm_errors: u32,
    pub dot12_in_oversize_frame_errors: u32,
    pub dot12_in_data_errors: u32,
    pub dot12_in_null_addressed_frames: u32,
    pub dot12_out_high_priority_frames: u32,
    pub dot12_out_high_priority_octets: u64,
    pub dot12_transition_into_trainings: u32,
    pub dot12_hc_in_high_priority_octets: u64,
    pub dot12_hc_in_norm_priority_octets: u64,
    pub dot12_hc_out_high_priority_octets: u64,
}

/// VLAN Counters - Format (0,5)
///
/// VLAN statistics
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* VLAN Counters */
/// /* opaque = counter_data; enterprise = 0; format = 5 */
///
/// struct vlan_counters {
///     unsigned int vlan_id;
///     unsigned hyper octets;
///     unsigned int ucastPkts;
///     unsigned int multicastPkts;
///     unsigned int broadcastPkts;
///     unsigned int discards;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VlanCounters {
    /// VLAN ID
    pub vlan_id: u32,

    /// Total octets
    pub octets: u64,

    /// Unicast packets
    pub ucast_pkts: u32,

    /// Multicast packets
    pub multicast_pkts: u32,

    /// Broadcast packets
    pub broadcast_pkts: u32,

    /// Discarded packets
    pub discards: u32,
}

/// IEEE 802.11 Counters - Format (0,6)
///
/// Wireless interface statistics
///
/// # XDR Definition ([sFlow 802.11](https://sflow.org/sflow_80211.txt))
///
/// ```text
/// /* IEEE802.11 interface counters - see IEEE802dot11-MIB */
/// /* opaque = counter_data; enterprise = 0; format = 6 */
///
/// struct ieee80211_counters {
///     unsigned int dot11TransmittedFragmentCount;
///     unsigned int dot11MulticastTransmittedFrameCount;
///     unsigned int dot11FailedCount;
///     unsigned int dot11RetryCount;
///     unsigned int dot11MultipleRetryCount;
///     unsigned int dot11FrameDuplicateCount;
///     unsigned int dot11RTSSuccessCount;
///     unsigned int dot11RTSFailureCount;
///     unsigned int dot11ACKFailureCount;
///     unsigned int dot11ReceivedFragmentCount;
///     unsigned int dot11MulticastReceivedFrameCount;
///     unsigned int dot11FCSErrorCount;
///     unsigned int dot11TransmittedFrameCount;
///     unsigned int dot11WEPUndecryptableCount;
///     unsigned int dot11QoSDiscardedFragmentCount;
///     unsigned int dot11AssociatedStationCount;
///     unsigned int dot11QoSCFPollsReceivedCount;
///     unsigned int dot11QoSCFPollsUnusedCount;
///     unsigned int dot11QoSCFPollsUnusableCount;
///     unsigned int dot11QoSCFPollsLostCount;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Ieee80211Counters {
    pub dot11_transmitted_fragment_count: u32,
    pub dot11_multicast_transmitted_frame_count: u32,
    pub dot11_failed_count: u32,
    pub dot11_retry_count: u32,
    pub dot11_multiple_retry_count: u32,
    pub dot11_frame_duplicate_count: u32,
    pub dot11_rts_success_count: u32,
    pub dot11_rts_failure_count: u32,
    pub dot11_ack_failure_count: u32,
    pub dot11_received_fragment_count: u32,
    pub dot11_multicast_received_frame_count: u32,
    pub dot11_fcs_error_count: u32,
    pub dot11_transmitted_frame_count: u32,
    pub dot11_wep_undecryptable_count: u32,
    pub dot11_qos_discarded_fragment_count: u32,
    pub dot11_associated_station_count: u32,
    pub dot11_qos_cf_polls_received_count: u32,
    pub dot11_qos_cf_polls_unused_count: u32,
    pub dot11_qos_cf_polls_unusable_count: u32,
    pub dot11_qos_cf_polls_lost_count: u32,
}

/// LAG Port Statistics - Format (0,7)
///
/// Link Aggregation (LAG) port statistics based on IEEE 802.1AX
///
/// # XDR Definition ([sFlow LAG](https://sflow.org/sflow_lag.txt))
///
/// ```text
/// /* LAG Port Statistics - see IEEE8023-LAG-MIB */
/// /* opaque = counter_data; enterprise = 0; format = 7 */
///
/// struct lag_port_stats {
///   mac dot3adAggPortActorSystemID;
///   mac dot3adAggPortPartnerOperSystemID;
///   unsigned int dot3adAggPortAttachedAggID;
///   opaque dot3adAggPortState[4]; /*
///                              Bytes are assigned in following order:
///                              byte 0, value dot3adAggPortActorAdminState
///                              byte 1, value dot3adAggPortActorOperState
///                              byte 2, value dot3adAggPortPartnerAdminState
///                              byte 3, value dot3adAggPortPartnerOperState
///                                  */
///   unsigned int dot3adAggPortStatsLACPDUsRx;
///   unsigned int dot3adAggPortStatsMarkerPDUsRx;
///   unsigned int dot3adAggPortStatsMarkerResponsePDUsRx;
///   unsigned int dot3adAggPortStatsUnknownRx;
///   unsigned int dot3adAggPortStatsIllegalRx;
///   unsigned int dot3adAggPortStatsLACPDUsTx;
///   unsigned int dot3adAggPortStatsMarkerPDUsTx;
///   unsigned int dot3adAggPortStatsMarkerResponsePDUsTx;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LagPortStats {
    /// Actor system ID (MAC address)
    pub dot3ad_agg_port_actor_system_id: crate::models::MacAddress,

    /// Partner operational system ID (MAC address)
    pub dot3ad_agg_port_partner_oper_system_id: crate::models::MacAddress,

    /// Attached aggregator ID
    pub dot3ad_agg_port_attached_agg_id: u32,

    /// Port state (4 bytes):
    /// - byte 0: dot3adAggPortActorAdminState
    /// - byte 1: dot3adAggPortActorOperState
    /// - byte 2: dot3adAggPortPartnerAdminState
    /// - byte 3: dot3adAggPortPartnerOperState
    pub dot3ad_agg_port_state: [u8; 4],

    /// LACP PDUs received
    pub dot3ad_agg_port_stats_lacpd_us_rx: u32,

    /// Marker PDUs received
    pub dot3ad_agg_port_stats_marker_pdus_rx: u32,

    /// Marker response PDUs received
    pub dot3ad_agg_port_stats_marker_response_pdus_rx: u32,

    /// Unknown PDUs received
    pub dot3ad_agg_port_stats_unknown_rx: u32,

    /// Illegal PDUs received
    pub dot3ad_agg_port_stats_illegal_rx: u32,

    /// LACP PDUs transmitted
    pub dot3ad_agg_port_stats_lacpd_us_tx: u32,

    /// Marker PDUs transmitted
    pub dot3ad_agg_port_stats_marker_pdus_tx: u32,

    /// Marker Response PDUs transmitted
    pub dot3ad_agg_port_stats_marker_response_pdus_tx: u32,
}

/// Slow Path Counts - Format (0,8)
///
/// Counts of packets processed via slow path (software) rather than fast path (hardware)
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/4JM1_Mmoz7w))
///
/// ```text
/// /* opaque = counter_data; enterprise = 0; format = 8 */
/// struct slow_path_counts {
///     unsigned int unknown;
///     unsigned int other;
///     unsigned int cam_miss;
///     unsigned int cam_full;
///     unsigned int no_hw_support;
///     unsigned int cntrl;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SlowPathCounts {
    /// Unknown reason
    pub unknown: u32,

    /// Other reason
    pub other: u32,

    /// CAM (Content Addressable Memory) miss
    pub cam_miss: u32,

    /// CAM full
    pub cam_full: u32,

    /// No hardware support
    pub no_hw_support: u32,

    /// Control packets (spec: cntrl)
    pub cntrl: u32,
}

/// InfiniBand Counters - Format (0,9)
///
/// InfiniBand port statistics
///
/// # XDR Definition ([sFlow InfiniBand](https://sflow.org/draft_sflow_infiniband_2.txt))
///
/// ```text
/// /* IB Counters */
/// /* opaque = counter_data; enterprise = 0; format = 9 */
///
/// struct ib_counters {
///    unsigned hyper PortXmitPkts; /* Total packets transmitted on all VLs */
///    unsigned hyper PortRcvPkts;  /* Total packets (may include packets containing errors */
///    unsigned int SymbolErrorCounter;
///    unsigned int LinkErrorRecoveryCounter;
///    unsigned int LinkDownedCounter;
///    unsigned int PortRcvErrors;
///    unsigned int PortRcvRemotePhysicalErrors;
///    unsigned int PortRcvSwitchRelayErrors;
///    unsigned int PortXmitDiscards;
///    unsigned int PortXmitConstraintErrors;
///    unsigned int PortRcvConstraintErrors;
///    unsigned int LocalLinkIntegrityErrors;
///    unsigned int ExcessiveBufferOverrunErrors;
///    unsigned int VL15Dropped;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct InfiniBandCounters {
    /// Total packets transmitted on all virtual lanes
    pub port_xmit_pkts: u64,

    /// Total packets received (may include packets containing errors)
    pub port_rcv_pkts: u64,

    /// Symbol error counter
    pub symbol_error_counter: u32,

    /// Link error recovery counter
    pub link_error_recovery_counter: u32,

    /// Link downed counter
    pub link_downed_counter: u32,

    /// Port receive errors
    pub port_rcv_errors: u32,

    /// Port receive remote physical errors
    pub port_rcv_remote_physical_errors: u32,

    /// Port receive switch relay errors
    pub port_rcv_switch_relay_errors: u32,

    /// Port transmit discards
    pub port_xmit_discards: u32,

    /// Port transmit constraint errors
    pub port_xmit_constraint_errors: u32,

    /// Port receive constraint errors
    pub port_rcv_constraint_errors: u32,

    /// Local link integrity errors
    pub local_link_integrity_errors: u32,

    /// Excessive buffer overrun errors
    pub excessive_buffer_overrun_errors: u32,

    /// VL15 dropped packets
    pub vl15_dropped: u32,
}

/// Optical Lane
///
/// Optical lane statistics for a single lane within an optical module
///
/// # XDR Definition ([sFlow Optics](https://sflow.org/sflow_optics.txt))
///
/// ```text
/// struct lane {
///   unsigned int index; /* 1-based index of lane within module, 0=unknown */
///   unsigned int tx_bias_current; /* microamps */
///   unsigned int tx_power;        /* microwatts */
///   unsigned int tx_power_min;    /* microwatts */
///   unsigned int tx_power_max;    /* microwatts */
///   unsigned int tx_wavelength;   /* nanometers */
///   unsigned int rx_power;        /* microwatts */
///   unsigned int rx_power_min;    /* microwatts */
///   unsigned int rx_power_max;    /* microwatts */
///   unsigned int rx_wavelength;   /* nanometers */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Lane {
    /// 1-based index of lane within module, 0=unknown
    pub index: u32,

    /// Transmit bias current in microamps
    pub tx_bias_current: u32,

    /// Transmit power in microwatts
    pub tx_power: u32,

    /// Minimum transmit power in microwatts
    pub tx_power_min: u32,

    /// Maximum transmit power in microwatts
    pub tx_power_max: u32,

    /// Transmit wavelength in nanometers
    pub tx_wavelength: u32,

    /// Receive power in microwatts
    pub rx_power: u32,

    /// Minimum receive power in microwatts
    pub rx_power_min: u32,

    /// Maximum receive power in microwatts
    pub rx_power_max: u32,

    /// Receive wavelength in nanometers
    pub rx_wavelength: u32,
}

/// Optical SFP/QSFP Counters - Format (0,10)
///
/// Optical interface module statistics for pluggable optical modules (SFP, QSFP, etc.)
///
/// # XDR Definition ([sFlow Optics](https://sflow.org/sflow_optics.txt))
///
/// ```text
/// /* Optical SFP / QSFP metrics */
/// /* opaque = counter_data; enterprise=0; format=10 */
/// struct sfp {
///   unsigned int module_id;
///   unsigned int module_num_lanes;      /* total number of lanes in module */
///   unsigned int module_supply_voltage; /* millivolts */
///   int module_temperature;             /* thousandths of a degree Celsius */
///   lane<> lanes;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OpticalSfpQsfp {
    /// Module identifier (ifIndex of module or lowest ifIndex of ports sharing module)
    pub module_id: u32,

    /// Total number of lanes in module
    pub module_num_lanes: u32,

    /// Module supply voltage in millivolts
    pub module_supply_voltage: u32,

    /// Module temperature in thousandths of a degree Celsius
    pub module_temperature: i32,

    /// Array of optical lane statistics
    pub lanes: Vec<Lane>,
}

/// Processor Counters - Format (0,1001)
///
/// CPU and memory utilization
///
/// # XDR Definition ([sFlow v5](https://sflow.org/sflow_version_5.txt))
///
/// ```text
/// /* Processor Information */
/// /* opaque = counter_data; enterprise = 0; format = 1001 */
///
/// struct processor {
///     percentage 5s_cpu;          /* 5 second average CPU utilization */
///     percentage 1m_cpu;          /* 1 minute average CPU utilization */
///     percentage 5m_cpu;          /* 5 minute average CPU utilization */
///     unsigned hyper total_memory; /* total memory (in bytes) */
///     unsigned hyper free_memory;  /* free memory (in bytes) */
/// }
/// ```
///
/// **ERRATUM:** The specification is missing semicolons after `total_memory` and `free_memory`,
/// violating RFC 4506 XDR syntax requirements. The corrected version is shown above.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ProcessorCounters {
    /// 5 second average CPU utilization (0-100%) (spec: 5s_cpu)
    pub cpu_5s: u32,

    /// 1 minute average CPU utilization (0-100%) (spec: 1m_cpu)
    pub cpu_1m: u32,

    /// 5 minute average CPU utilization (0-100%) (spec: 5m_cpu)
    pub cpu_5m: u32,

    /// Total memory in bytes
    pub total_memory: u64,

    /// Free memory in bytes
    pub free_memory: u64,
}

/// Radio Utilization - Format (0,1002)
///
/// 802.11 radio channel utilization
///
/// # XDR Definition ([sFlow 802.11](https://sflow.org/sflow_80211.txt))
///
/// ```text
/// /* 802.11 radio utilization */
/// /* opaque = counter_data; enterprise = 0; format = 1002 */
///
/// struct radio_utilization {
///     unsigned int elapsed_time;        /* Elapsed time in ms */
///     unsigned int on_channel_time;     /* Time on assigned channel */
///     unsigned int on_channel_busy_time;/* Time busy on channel */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RadioUtilization {
    /// Elapsed time in milliseconds
    pub elapsed_time: u32,

    /// On channel time
    pub on_channel_time: u32,

    /// On channel busy time
    pub on_channel_busy_time: u32,
}

/// Queue Length - Format (0,1003)
///
/// Histogram of queue lengths experienced by packets when they are enqueued
///
/// # XDR Definition ([sFlow Discussion](http://groups.google.com/group/sflow/browse_thread/thread/773d27b17a81600c))
///
/// ```text
/// /* Queue length counters
///    Histogram of queue lengths experienced by packets when they are
///    enqueued (ie queue length immediately before packet is enqueued)
///    thus giving the queue lengths experienced by each packet.
///    Queue length is measured in segments occupied by the enqueued
///    packets.
///    Queue length counter records for each of the queues for a
///    port must be exported with the generic interface counters
///    record, if_counters, for the port.*/
///
/// /* Queue length histogram counters
///    opaque = counter_data; enterprise = 0; format = 1003 */
///
/// struct queue_length {
///     unsigned int queueIndex; /* persistent index of queue within port */
///     unsigned int segmentSize; /* size of queue segment in bytes */
///     unsigned int queueSegments; /* total number of segments allocated
///                                    (ie available) to this queue. */
///     unsigned int queueLength0; /* queue is empty when a packet is
///                                   enqueued. */
///     unsigned int queueLength1; /* queue length == 1 segment when a
///                                   packet is enqueued. */
///     unsigned int queueLength2; /* queue length == 2 segments when a
///                                   packet is enqueued. */
///     unsigned int queueLength4; /* 2 segments > queue length <= 4
///                                   segments when a packet is enqueued. */
///     unsigned int queueLength8; /* 4 segments > queue length <= 8
///                                   segments when packet is enqueued. */
///     unsigned int queueLength32; /* 8 segments > queue length <= 32
///                                    segments when packet is enqueued. */
///     unsigned int queueLength128; /* 32 segments > queue length <= 128
///                                     segments when packet is enqueued. */
///     unsigned int queueLength1024; /* 128 segments > queue length <= 1024
///                                      segments when packet is enqueued. */
///     unsigned int queueLengthMore; /* queue length > 1024 segments when
///                                      packet is enqueued. */
///     unsigned int dropped; /* count of packets intended for this queue
///                              that are dropped on enqueuing. */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct QueueLength {
    /// Persistent index of queue within port
    pub queue_index: u32,

    /// Size of queue segment in bytes
    pub segment_size: u32,

    /// Total number of segments allocated (available) to this queue
    pub queue_segments: u32,

    /// Queue is empty when a packet is enqueued
    pub queue_length_0: u32,

    /// Queue length == 1 segment when a packet is enqueued
    pub queue_length_1: u32,

    /// Queue length == 2 segments when a packet is enqueued
    pub queue_length_2: u32,

    /// 2 segments > queue length <= 4 segments when a packet is enqueued
    pub queue_length_4: u32,

    /// 4 segments > queue length <= 8 segments when packet is enqueued
    pub queue_length_8: u32,

    /// 8 segments > queue length <= 32 segments when packet is enqueued
    pub queue_length_32: u32,

    /// 32 segments > queue length <= 128 segments when packet is enqueued
    pub queue_length_128: u32,

    /// 128 segments > queue length <= 1024 segments when packet is enqueued
    pub queue_length_1024: u32,

    /// Queue length > 1024 segments when packet is enqueued
    pub queue_length_more: u32,

    /// Count of packets intended for this queue that are dropped on enqueuing
    pub dropped: u32,
}

/// OpenFlow Port - Format (0,1004)
///
/// OpenFlow port statistics
///
/// # XDR Definition ([sFlow OpenFlow](https://sflow.org/sflow_openflow.txt))
///
/// ```text
/// /* OpenFlow port */
/// /* opaque = counter_data; enterprise = 0; format = 1004 */
///
/// struct of_port {
///     unsigned hyper datapath_id;
///     unsigned int port_no;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OpenFlowPort {
    /// Datapath ID
    pub datapath_id: u64,

    /// Port number
    pub port_no: u32,
}

/// OpenFlow Port Name - Format (0,1005)
///
/// OpenFlow port name string
///
/// # XDR Definition ([sFlow OpenFlow](https://sflow.org/sflow_openflow.txt))
///
/// ```text
/// /* Port name */
/// /* opaque = counter_data; enterprise = 0; format = 1005 */
///
/// struct port_name {
///     string name<>;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OpenFlowPortName {
    /// Port name
    pub port_name: String,
}

/// Machine Type enumeration
///
/// Processor family types as defined in sFlow v5 specification
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// enum machine_type {
///    unknown = 0,
///    other   = 1,
///    x86     = 2,
///    x86_64  = 3,
///    ia64    = 4,
///    sparc   = 5,
///    alpha   = 6,
///    powerpc = 7,
///    m68k    = 8,
///    mips    = 9,
///    arm     = 10,
///    hppa    = 11,
///    s390    = 12
/// }
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u32)]
pub enum MachineType {
    Unknown = 0,
    Other = 1,
    X86 = 2,
    X86_64 = 3,
    Ia64 = 4,
    Sparc = 5,
    Alpha = 6,
    Powerpc = 7,
    M68k = 8,
    Mips = 9,
    Arm = 10,
    Hppa = 11,
    S390 = 12,
}

impl From<u32> for MachineType {
    fn from(value: u32) -> Self {
        match value {
            0 => MachineType::Unknown,
            1 => MachineType::Other,
            2 => MachineType::X86,
            3 => MachineType::X86_64,
            4 => MachineType::Ia64,
            5 => MachineType::Sparc,
            6 => MachineType::Alpha,
            7 => MachineType::Powerpc,
            8 => MachineType::M68k,
            9 => MachineType::Mips,
            10 => MachineType::Arm,
            11 => MachineType::Hppa,
            12 => MachineType::S390,
            _ => MachineType::Unknown,
        }
    }
}

/// Operating System Name enumeration
///
/// OS types as defined in sFlow v5 specification
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// enum os_name {
///    unknown   = 0,
///    other     = 1,
///    linux     = 2,
///    windows   = 3,
///    darwin    = 4,
///    hpux      = 5,
///    aix       = 6,
///    dragonfly = 7,
///    freebsd   = 8,
///    netbsd    = 9,
///    openbsd   = 10,
///    osf       = 11,
///    solaris   = 12
/// }
/// ```
///
/// **Note:** The enumeration may be expanded over time. Applications receiving
/// sFlow must be prepared to receive host_descr structures with unknown os_name values.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u32)]
pub enum OsName {
    Unknown = 0,
    Other = 1,
    Linux = 2,
    Windows = 3,
    Darwin = 4,
    Hpux = 5,
    Aix = 6,
    Dragonfly = 7,
    Freebsd = 8,
    Netbsd = 9,
    Openbsd = 10,
    Osf = 11,
    Solaris = 12,
}

impl From<u32> for OsName {
    fn from(value: u32) -> Self {
        match value {
            0 => OsName::Unknown,
            1 => OsName::Other,
            2 => OsName::Linux,
            3 => OsName::Windows,
            4 => OsName::Darwin,
            5 => OsName::Hpux,
            6 => OsName::Aix,
            7 => OsName::Dragonfly,
            8 => OsName::Freebsd,
            9 => OsName::Netbsd,
            10 => OsName::Openbsd,
            11 => OsName::Osf,
            12 => OsName::Solaris,
            _ => OsName::Unknown,
        }
    }
}

/// Host Description - Format (0,2000)
///
/// Physical or virtual host description
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Physical or virtual host description */
/// /* opaque = counter_data; enterprise = 0; format = 2000 */
///
/// struct host_descr {
///    string hostname<64>;       /* hostname, empty if unknown */
///    opaque uuid<16>;           /* 16 bytes binary UUID, empty if unknown */
///    machine_type machine_type; /* the processor family */
///    os_name os_name;           /* Operating system */
///    string os_release<32>;     /* e.g. 2.6.9-42.ELsmp,xp-sp3, empty if unknown */
/// }
/// ```
///
/// **ERRATUM:** UUID field changed from `opaque uuid<16>` to `opaque uuid[16]` (fixed array).
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostDescription {
    /// Hostname
    pub hostname: String,

    /// UUID (16 bytes)
    /// **ERRATUM:** All zeros if unknown (changed from variable-length to fixed-length array)
    pub uuid: [u8; 16],

    /// Machine type (processor family)
    pub machine_type: MachineType,

    /// Operating system name
    pub os_name: OsName,

    /// OS release (e.g., "5.10.0")
    pub os_release: String,
}

/// Host Adapters - Format (0,2001)
///
/// Set of network adapters associated with entity
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Set of adapters associated with entity */
/// /* opaque = counter_data; enterprise = 0; format = 2001 */
///
/// struct host_adapters {
///     adapter adapters<>; /* adapter(s) associated with entity */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostAdapters {
    /// Adapters
    pub adapters: Vec<HostAdapter>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostAdapter {
    /// Interface index
    pub if_index: u32,

    /// MAC addresses
    pub mac_addresses: Vec<crate::models::MacAddress>,
}

/// Host Parent - Format (0,2002)
///
/// Containment hierarchy between logical and physical entities
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Define containment hierarchy */
/// /* opaque = counter_data; enterprise = 0; format = 2002 */
///
/// struct host_parent {
///     unsigned int container_type;  /* sFlowDataSource type */
///     unsigned int container_index; /* sFlowDataSource index */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostParent {
    /// Container type (e.g., "docker", "lxc")
    pub container_type: u32,

    /// Container index
    pub container_index: u32,
}

/// Host CPU - Format (0,2003)
///
/// Physical server CPU statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Physical Server CPU */
/// /* opaque = counter_data; enterprise = 0; format = 2003 */
///
/// struct host_cpu {
///     float load_one;          /* 1 minute load avg */
///     float load_five;         /* 5 minute load avg */
///     float load_fifteen;      /* 15 minute load avg */
///     unsigned int proc_run;   /* running processes */
///     unsigned int proc_total; /* total processes */
///     unsigned int cpu_num;    /* number of CPUs */
///     unsigned int cpu_speed;  /* CPU speed in MHz */
///     unsigned int uptime;     /* seconds since last reboot */
///     unsigned int cpu_user;   /* user time (ms) */
///     unsigned int cpu_nice;   /* nice time (ms) */
///     unsigned int cpu_system; /* system time (ms) */
///     unsigned int cpu_idle;   /* idle time (ms) */
///     unsigned int cpu_wio;    /* I/O wait time (ms) */
///     unsigned int cpu_intr;   /* interrupt time (ms) */
///     unsigned int cpu_sintr;  /* soft interrupt time (ms) */
///     unsigned int interrupts; /* interrupt count */
///     unsigned int contexts;   /* context switch count */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostCpu {
    /// Load average (1 minute) - stored as hundredths (multiply by 100)
    pub load_one: u32,

    /// Load average (5 minutes) - stored as hundredths (multiply by 100)
    pub load_five: u32,

    /// Load average (15 minutes) - stored as hundredths (multiply by 100)
    pub load_fifteen: u32,

    /// Number of running processes
    pub proc_run: u32,

    /// Total number of processes
    pub proc_total: u32,

    /// Number of CPUs
    pub cpu_num: u32,

    /// CPU speed in MHz
    pub cpu_speed: u32,

    /// CPU uptime in seconds
    pub uptime: u32,

    /// CPU time in user mode (ms)
    pub cpu_user: u32,

    /// CPU time in nice mode (ms)
    pub cpu_nice: u32,

    /// CPU time in system mode (ms)
    pub cpu_system: u32,

    /// CPU idle time (ms)
    pub cpu_idle: u32,

    /// CPU time waiting for I/O (ms)
    pub cpu_wio: u32,

    /// CPU time servicing interrupts (ms)
    pub cpu_intr: u32,

    /// CPU time servicing soft interrupts (ms)
    pub cpu_sintr: u32,

    /// Number of interrupts
    pub interrupts: u32,

    /// Number of context switches
    pub contexts: u32,
}

/// Host Memory - Format (0,2004)
///
/// Physical server memory statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Physical Server Memory */
/// /* opaque = counter_data; enterprise = 0; format = 2004 */
///
/// struct host_memory {
///     unsigned hyper mem_total;   /* total bytes */
///     unsigned hyper mem_free;    /* free bytes */
///     unsigned hyper mem_shared;  /* shared bytes */
///     unsigned hyper mem_buffers; /* buffers bytes */
///     unsigned hyper mem_cached;  /* cached bytes */
///     unsigned hyper swap_total;  /* swap total bytes */
///     unsigned hyper swap_free;   /* swap free bytes */
///     unsigned int page_in;       /* page in count */
///     unsigned int page_out;      /* page out count */
///     unsigned int swap_in;       /* swap in count */
///     unsigned int swap_out;      /* swap out count */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostMemory {
    /// Total memory in bytes
    pub mem_total: u64,

    /// Free memory in bytes
    pub mem_free: u64,

    /// Shared memory in bytes
    pub mem_shared: u64,

    /// Memory used for buffers in bytes
    pub mem_buffers: u64,

    /// Memory used for cache in bytes
    pub mem_cached: u64,

    /// Total swap space in bytes
    pub swap_total: u64,

    /// Free swap space in bytes
    pub swap_free: u64,

    /// Page in count
    pub page_in: u32,

    /// Page out count
    pub page_out: u32,

    /// Swap in count
    pub swap_in: u32,

    /// Swap out count
    pub swap_out: u32,
}

/// Host Disk I/O - Format (0,2005)
///
/// Physical server disk I/O statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Physical Server Disk I/O */
/// /* opaque = counter_data; enterprise = 0; format = 2005 */
///
/// struct host_disk_io {
///     unsigned hyper disk_total;    /* total disk size in bytes */
///     unsigned hyper disk_free;     /* total disk free in bytes */
///     percentage part_max_used;     /* utilization of most utilized partition */
///     unsigned int reads;           /* reads issued */
///     unsigned hyper bytes_read;    /* bytes read */
///     unsigned int read_time;       /* read time (ms) */
///     unsigned int writes;          /* writes completed */
///     unsigned hyper bytes_written; /* bytes written */
///     unsigned int write_time;      /* write time (ms) */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostDiskIo {
    /// Total disk capacity in bytes
    pub disk_total: u64,

    /// Free disk space in bytes
    pub disk_free: u64,

    /// Percentage of disk used (in hundredths of a percent, e.g., 100 = 1%)
    pub part_max_used: i32,

    /// Number of disk reads
    pub reads: u32,

    /// Bytes read from disk
    pub bytes_read: u64,

    /// Read time in milliseconds
    pub read_time: u32,

    /// Number of disk writes
    pub writes: u32,

    /// Bytes written to disk
    pub bytes_written: u64,

    /// Write time in milliseconds
    pub write_time: u32,
}

/// Host Network I/O - Format (0,2006)
///
/// Physical server network I/O statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Physical Server Network I/O */
/// /* opaque = counter_data; enterprise = 0; format = 2006 */
///
/// struct host_net_io {
///     unsigned hyper bytes_in;  /* total bytes in */
///     unsigned int pkts_in;     /* total packets in */
///     unsigned int errs_in;     /* total errors in */
///     unsigned int drops_in;    /* total drops in */
///     unsigned hyper bytes_out; /* total bytes out */
///     unsigned int packets_out; /* total packets out */
///     unsigned int errs_out;    /* total errors out */
///     unsigned int drops_out;   /* total drops out */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HostNetIo {
    /// Bytes received
    pub bytes_in: u64,

    /// Packets received
    pub pkts_in: u32,

    /// Receive errors
    pub errs_in: u32,

    /// Receive drops
    pub drops_in: u32,

    /// Bytes transmitted
    pub bytes_out: u64,

    /// Packets transmitted
    pub packets_out: u32,

    /// Transmit errors
    pub errs_out: u32,

    /// Transmit drops
    pub drops_out: u32,
}

/// MIB-2 IP Group - Format (0,2007)
///
/// IP protocol statistics from MIB-II
///
/// # XDR Definition ([sFlow Host TCP/IP](https://sflow.org/sflow_host_ip.txt))
///
/// ```text
/// /* IP Group - see MIB-II */
/// /* opaque = counter_data; enterprise = 0; format = 2007 */
///
/// struct mib2_ip_group {
///   unsigned int ipForwarding;
///   unsigned int ipDefaultTTL;
///   unsigned int ipInReceives;
///   unsigned int ipInHdrErrors;
///   unsigned int ipInAddrErrors;
///   unsigned int ipForwDatagrams;
///   unsigned int ipInUnknownProtos;
///   unsigned int ipInDiscards;
///   unsigned int ipInDelivers;
///   unsigned int ipOutRequests;
///   unsigned int ipOutDiscards;
///   unsigned int ipOutNoRoutes;
///   unsigned int ipReasmTimeout;
///   unsigned int ipReasmReqds;
///   unsigned int ipReasmOKs;
///   unsigned int ipReasmFails;
///   unsigned int ipFragOKs;
///   unsigned int ipFragFails;
///   unsigned int ipFragCreates;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Mib2IpGroup {
    pub ip_forwarding: u32,
    pub ip_default_ttl: u32,
    pub ip_in_receives: u32,
    pub ip_in_hdr_errors: u32,
    pub ip_in_addr_errors: u32,
    pub ip_forw_datagrams: u32,
    pub ip_in_unknown_protos: u32,
    pub ip_in_discards: u32,
    pub ip_in_delivers: u32,
    pub ip_out_requests: u32,
    pub ip_out_discards: u32,
    pub ip_out_no_routes: u32,
    pub ip_reasm_timeout: u32,
    pub ip_reasm_reqds: u32,
    pub ip_reasm_oks: u32,
    pub ip_reasm_fails: u32,
    pub ip_frag_oks: u32,
    pub ip_frag_fails: u32,
    pub ip_frag_creates: u32,
}

/// MIB-2 ICMP Group - Format (0,2008)
///
/// ICMP protocol statistics from MIB-II
///
/// # XDR Definition ([sFlow Host TCP/IP](https://sflow.org/sflow_host_ip.txt))
///
/// ```text
/// /* ICMP Group - see MIB-II */
/// /* opaque = counter_data; enterprise = 0; format = 2008 */
///
/// struct mib2_icmp_group {
///   unsigned int icmpInMsgs;
///   unsigned int icmpInErrors;
///   unsigned int icmpInDestUnreachs;
///   unsigned int icmpInTimeExcds;
///   unsigned int icmpInParamProbs;
///   unsigned int icmpInSrcQuenchs;
///   unsigned int icmpInRedirects;
///   unsigned int icmpInEchos;
///   unsigned int icmpInEchoReps;
///   unsigned int icmpInTimestamps;
///   unsigned int icmpInAddrMasks;
///   unsigned int icmpInAddrMaskReps;
///   unsigned int icmpOutMsgs;
///   unsigned int icmpOutErrors;
///   unsigned int icmpOutDestUnreachs;
///   unsigned int icmpOutTimeExcds;
///   unsigned int icmpOutParamProbs;
///   unsigned int icmpOutSrcQuenchs;
///   unsigned int icmpOutRedirects;
///   unsigned int icmpOutEchos;
///   unsigned int icmpOutEchoReps;
///   unsigned int icmpOutTimestamps;
///   unsigned int icmpOutTimestampReps;
///   unsigned int icmpOutAddrMasks;
///   unsigned int icmpOutAddrMaskReps;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Mib2IcmpGroup {
    pub icmp_in_msgs: u32,
    pub icmp_in_errors: u32,
    pub icmp_in_dest_unreachs: u32,
    pub icmp_in_time_excds: u32,
    pub icmp_in_param_probs: u32,
    pub icmp_in_src_quenchs: u32,
    pub icmp_in_redirects: u32,
    pub icmp_in_echos: u32,
    pub icmp_in_echo_reps: u32,
    pub icmp_in_timestamps: u32,
    pub icmp_in_addr_masks: u32,
    pub icmp_in_addr_mask_reps: u32,
    pub icmp_out_msgs: u32,
    pub icmp_out_errors: u32,
    pub icmp_out_dest_unreachs: u32,
    pub icmp_out_time_excds: u32,
    pub icmp_out_param_probs: u32,
    pub icmp_out_src_quenchs: u32,
    pub icmp_out_redirects: u32,
    pub icmp_out_echos: u32,
    pub icmp_out_echo_reps: u32,
    pub icmp_out_timestamps: u32,
    pub icmp_out_timestamp_reps: u32,
    pub icmp_out_addr_masks: u32,
    pub icmp_out_addr_mask_reps: u32,
}

/// MIB-2 TCP Group - Format (0,2009)
///
/// TCP protocol statistics from MIB-II
///
/// # XDR Definition ([sFlow Host TCP/IP](https://sflow.org/sflow_host_ip.txt))
///
/// ```text
/// /* TCP Group - see MIB-II */
/// /* opaque = counter_data; enterprise = 0; format = 2009 */
///
/// struct mib2_tcp_group {
///   unsigned int tcpRtoAlgorithm;
///   unsigned int tcpRtoMin;
///   unsigned int tcpRtoMax;
///   unsigned int tcpMaxConn;
///   unsigned int tcpActiveOpens;
///   unsigned int tcpPassiveOpens;
///   unsigned int tcpAttemptFails;
///   unsigned int tcpEstabResets;
///   unsigned int tcpCurrEstab;
///   unsigned int tcpInSegs;
///   unsigned int tcpOutSegs;
///   unsigned int tcpRetransSegs;
///   unsigned int tcpInErrs;
///   unsigned int tcpOutRsts;
///   unsigned int tcpInCsumErrs;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Mib2TcpGroup {
    pub tcp_rto_algorithm: u32,
    pub tcp_rto_min: u32,
    pub tcp_rto_max: u32,
    pub tcp_max_conn: u32,
    pub tcp_active_opens: u32,
    pub tcp_passive_opens: u32,
    pub tcp_attempt_fails: u32,
    pub tcp_estab_resets: u32,
    pub tcp_curr_estab: u32,
    pub tcp_in_segs: u32,
    pub tcp_out_segs: u32,
    pub tcp_retrans_segs: u32,
    pub tcp_in_errs: u32,
    pub tcp_out_rsts: u32,
    pub tcp_in_csum_errs: u32,
}

/// MIB-2 UDP Group - Format (0,2010)
///
/// UDP protocol statistics from MIB-II
///
/// # XDR Definition ([sFlow Host TCP/IP](https://sflow.org/sflow_host_ip.txt))
///
/// ```text
/// /* UDP Group - see MIB-II */
/// /* opaque = counter_data; enterprise = 0; format = 2010 */
///
/// struct mib2_udp_group {
///   unsigned int udpInDatagrams;
///   unsigned int udpNoPorts;
///   unsigned int udpInErrors;
///   unsigned int udpOutDatagrams;
///   unsigned int udpRcvbufErrors;
///   unsigned int udpSndbufErrors;
///   unsigned int udpInCsumErrors;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Mib2UdpGroup {
    pub udp_in_datagrams: u32,
    pub udp_no_ports: u32,
    pub udp_in_errors: u32,
    pub udp_out_datagrams: u32,
    pub udp_rcvbuf_errors: u32,
    pub udp_sndbuf_errors: u32,
    pub udp_in_csum_errors: u32,
}

/// Virtual Node - Format (0,2100)
///
/// Hypervisor statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Virtual Node Statistics */
/// /* opaque = counter_data; enterprise = 0; format = 2100 */
///
/// struct virt_node {
///     unsigned int mhz;           /* expected CPU frequency */
///     unsigned int cpus;          /* number of active CPUs */
///     unsigned hyper memory;      /* memory size in bytes */
///     unsigned hyper memory_free; /* unassigned memory in bytes */
///     unsigned int num_domains;   /* number of active domains */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VirtualNode {
    /// Expected CPU frequency in MHz
    pub mhz: u32,

    /// Number of active CPUs
    pub cpus: u32,

    /// Memory size in bytes
    pub memory: u64,

    /// Unassigned memory in bytes
    pub memory_free: u64,

    /// Number of active domains
    pub num_domains: u32,
}

/// Virtual CPU - Format (0,2101)
///
/// Virtual domain CPU statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Virtual Domain CPU statistics */
/// /* See libvirt, struct virDomainInfo */
/// /* opaque = counter_data; enterprise = 0; format = 2101 */
///
/// struct virt_cpu {
///     unsigned int state;    /* virtDomainState */
///     unsigned int cpuTime;  /* CPU time used (ms) */
///     unsigned int nrVirtCpu;/* number of virtual CPUs */
/// }
/// ```
///
/// **ERRATUM:** Comment reference corrected from `virtDomainInfo` to `virDomainInfo`.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VirtualCpu {
    /// CPU state (0=running, 1=idle, 2=blocked)
    pub state: u32,

    /// CPU time in milliseconds
    pub cpu_time: u32,

    /// Number of virtual CPUs
    pub nr_virt_cpu: u32,
}

/// Virtual Memory - Format (0,2102)
///
/// Virtual domain memory statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Virtual Domain Memory statistics */
/// /* See libvirt, struct virDomainInfo */
/// /* opaque = counter_data; enterprise = 0; format = 2102 */
///
/// struct virt_memory {
///     unsigned hyper memory;    /* memory in bytes used by domain */
///     unsigned hyper maxMemory; /* memory in bytes allowed */
/// }
/// ```
///
/// **ERRATUM:** Comment reference corrected from `virtDomainInfo` to `virDomainInfo`.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VirtualMemory {
    /// Memory in bytes
    pub memory: u64,

    /// Maximum memory in bytes
    pub max_memory: u64,
}

/// Virtual Disk I/O - Format (0,2103)
///
/// Virtual domain disk statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Virtual Domain Disk statistics */
/// /* See libvirt, struct virDomainBlockInfo */
/// /* See libvirt, struct virDomainBlockStatsStruct */
/// /* opaque = counter_data; enterprise = 0; format = 2103 */
///
/// struct virt_disk_io {
///     unsigned hyper capacity;   /* logical size in bytes */
///     unsigned hyper allocation; /* current allocation in bytes */
///     unsigned hyper physical;   /* physical size in bytes of the container of the backing image */
///     unsigned int rd_req;       /* number of read requests */
///     unsigned hyper rd_bytes;   /* number of read bytes */
///     unsigned int wr_req;       /* number of write requests */
///     unsigned hyper wr_bytes;   /* number of written bytes */
///     unsigned int errs;         /* read/write errors */
/// }
/// ```
///
/// **ERRATUM:** Field name changed from `available` to `physical`, and comment references corrected
/// from `virtDomainBlockInfo`/`virtDomainBlockStatsStruct` to `virDomainBlockInfo`/`virDomainBlockStatsStruct`.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VirtualDiskIo {
    /// Capacity in bytes
    pub capacity: u64,

    /// Allocation in bytes
    pub allocation: u64,

    /// Physical size in bytes of the container of the backing image (spec: physical)
    /// **ERRATUM:** Field renamed from `available` (remaining free bytes) to `physical`
    pub available: u64,

    /// Read requests
    pub rd_req: u32,

    /// Bytes read
    pub rd_bytes: u64,

    /// Write requests
    pub wr_req: u32,

    /// Bytes written
    pub wr_bytes: u64,

    /// Errors
    pub errs: u32,
}

/// Virtual Network I/O - Format (0,2104)
///
/// Virtual domain network statistics
///
/// # XDR Definition ([sFlow Host](https://sflow.org/sflow_host.txt))
///
/// ```text
/// /* Virtual Domain Network statistics */
/// /* See libvirt, struct virDomainInterfaceStatsStruct */
/// /* opaque = counter_data; enterprise = 0; format = 2104 */
///
/// struct virt_net_io {
///     unsigned hyper rx_bytes;  /* total bytes received */
///     unsigned int rx_packets;  /* total packets received */
///     unsigned int rx_errs;     /* total receive errors */
///     unsigned int rx_drop;     /* total receive drops */
///     unsigned hyper tx_bytes;  /* total bytes transmitted */
///     unsigned int tx_packets;  /* total packets transmitted */
///     unsigned int tx_errs;     /* total transmit errors */
///     unsigned int tx_drop;     /* total transmit drops */
/// }
/// ```
///
/// **ERRATUM:** Comment reference corrected from `virtDomainInterfaceStatsStruct` to `virDomainInterfaceStatsStruct`.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VirtualNetIo {
    /// Bytes received
    pub rx_bytes: u64,

    /// Packets received
    pub rx_packets: u32,

    /// Receive errors
    pub rx_errs: u32,

    /// Receive drops
    pub rx_drop: u32,

    /// Bytes transmitted
    pub tx_bytes: u64,

    /// Packets transmitted
    pub tx_packets: u32,

    /// Transmit errors
    pub tx_errs: u32,

    /// Transmit drops
    pub tx_drop: u32,
}

/// JVM Runtime - Format (0,2105)
///
/// Java Virtual Machine runtime attributes
///
/// # XDR Definition ([sFlow JVM](https://sflow.org/sflow_jvm.txt))
///
/// ```text
/// /* JVM Runtime Attributes */
/// /* See RuntimeMXBean */
/// /* opaque = counter_data; enterprise = 0; format = 2105 */
///
/// struct jvm_runtime {
///   string vm_name<64>;      /* vm name */
///   string vm_vendor<32>;    /* the vendor for the JVM */
///   string vm_version<32>;   /* the version for the JVM */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JvmRuntime {
    /// JVM name
    pub vm_name: String,

    /// JVM vendor
    pub vm_vendor: String,

    /// JVM version
    pub vm_version: String,
}

/// JVM Statistics - Format (0,2106)
///
/// Java Virtual Machine performance statistics
///
/// # XDR Definition ([sFlow JVM](https://sflow.org/sflow_jvm.txt))
///
/// ```text
/// /* JVM Statistics */
/// /* See MemoryMXBean, GarbageCollectorMXBean, ClassLoadingMXBean, */
/// /* CompilationMXBean, ThreadMXBean and UnixOperatingSystemMXBean */
/// /* opaque = counter_data; enterprise = 0; format = 2106 */
///
/// struct jvm_statistics {
///   unsigned hyper heap_initial;    /* initial heap memory requested */
///   unsigned hyper heap_used;       /* current heap memory usage  */
///   unsigned hyper heap_committed;  /* heap memory currently committed */
///   unsigned hyper heap_max;        /* max heap space */
///   unsigned hyper non_heap_initial; /* initial non heap memory
///                                       requested */
///   unsigned hyper non_heap_used;   /* current non heap memory usage  */
///   unsigned hyper non_heap_committed; /* non heap memory currently
///                                         committed */
///   unsigned hyper non_heap_max;    /* max non-heap space */
///   unsigned int gc_count;          /* total number of collections that
///                                      have occurred */
///   unsigned int gc_time;           /* approximate accumulated collection
///                                      elapsed time in milliseconds */
///   unsigned int classes_loaded;    /* number of classes currently loaded
///                                      in vm */
///   unsigned int classes_total;     /* total number of classes loaded
///                                      since vm started */
///   unsigned int classes_unloaded;  /* total number of classe unloaded
///                                      since vm started */
///   unsigned int compilation_time;  /* total accumulated time spent in
///                                      compilation (in milliseconds) */
///   unsigned int thread_num_live;   /* current number of live threads */
///   unsigned int thread_num_daemon; /* current number of live daemon
///                                      threads */
///   unsigned int thread_num_started; /* total threads started since
///                                       vm started */
///   unsigned int fd_open_count;     /* number of open file descriptors */
///   unsigned int fd_max_count;      /* max number of file descriptors */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JvmStatistics {
    /// Initial heap memory requested
    pub heap_initial: u64,

    /// Current heap memory usage
    pub heap_used: u64,

    /// Heap memory currently committed
    pub heap_committed: u64,

    /// Maximum heap space
    pub heap_max: u64,

    /// Initial non-heap memory requested
    pub non_heap_initial: u64,

    /// Current non-heap memory usage
    pub non_heap_used: u64,

    /// Non-heap memory currently committed
    pub non_heap_committed: u64,

    /// Maximum non-heap space
    pub non_heap_max: u64,

    /// Total number of garbage collections that have occurred
    pub gc_count: u32,

    /// Approximate accumulated collection elapsed time in milliseconds
    pub gc_time: u32,

    /// Number of classes currently loaded in VM
    pub classes_loaded: u32,

    /// Total number of classes loaded since VM started
    pub classes_total: u32,

    /// Total number of classes unloaded since VM started
    pub classes_unloaded: u32,

    /// Total accumulated time spent in compilation (in milliseconds)
    pub compilation_time: u32,

    /// Current number of live threads
    pub thread_num_live: u32,

    /// Current number of live daemon threads
    pub thread_num_daemon: u32,

    /// Total threads started since VM started
    pub thread_num_started: u32,

    /// Number of open file descriptors
    pub fd_open_count: u32,

    /// Maximum number of file descriptors
    pub fd_max_count: u32,
}

/// Memcache Counters - Format (0,2200) - **DEPRECATED**
///
/// Legacy memcache statistics counters
///
/// **Note:** This format was defined in an early sFlow Memcache discussion
/// but was deprecated and replaced by format 2204. It is included here for
/// backward compatibility with legacy implementations.
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/KDk_QrxCSJI))
///
/// ```text
/// /* Memcached counters */
/// /* See memcached protocol.txt */
/// /* opaque = counter_data; enterprise = 0; format = 2200 */
/// struct memcached_counters {
///   unsigned int uptime;                 /* in seconds */
///   unsigned int rusage_user;            /* in milliseconds */
///   unsigned int rusage_system;          /* in milliseconds */
///   unsigned int curr_connections;
///   unsigned int total_connections;
///   unsigned int connection_structures;
///   unsigned int cmd_get;
///   unsigned int cmd_set;
///   unsigned int cmd_flush;
///   unsigned int get_hits;
///   unsigned int get_misses;
///   unsigned int delete_misses;
///   unsigned int delete_hits;
///   unsigned int incr_misses;
///   unsigned int incr_hits;
///   unsigned int decr_misses;
///   unsigned int decr_hits;
///   unsigned int cas_misses;
///   unsigned int cas_hits;
///   unsigned int cas_badval;
///   unsigned int auth_cmds;
///   unsigned int auth_errors;
///   unsigned hyper bytes_read;
///   unsigned hyper bytes_written;
///   unsigned int limit_maxbytes;
///   unsigned int accepting_conns;
///   unsigned int listen_disabled_num;
///   unsigned int threads;
///   unsigned int conn_yields;
///   unsigned hyper bytes;
///   unsigned int curr_items;
///   unsigned int total_items;
///   unsigned int evictions;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MemcacheCountersDeprecated {
    /// Uptime in seconds
    pub uptime: u32,

    /// User CPU time in milliseconds
    pub rusage_user: u32,

    /// System CPU time in milliseconds
    pub rusage_system: u32,

    /// Current number of connections
    pub curr_connections: u32,

    /// Total number of connections
    pub total_connections: u32,

    /// Number of connection structures
    pub connection_structures: u32,

    /// Number of get commands
    pub cmd_get: u32,

    /// Number of set commands
    pub cmd_set: u32,

    /// Number of flush commands
    pub cmd_flush: u32,

    /// Number of get hits
    pub get_hits: u32,

    /// Number of get misses
    pub get_misses: u32,

    /// Number of delete misses
    pub delete_misses: u32,

    /// Number of delete hits
    pub delete_hits: u32,

    /// Number of increment misses
    pub incr_misses: u32,

    /// Number of increment hits
    pub incr_hits: u32,

    /// Number of decrement misses
    pub decr_misses: u32,

    /// Number of decrement hits
    pub decr_hits: u32,

    /// Number of CAS misses
    pub cas_misses: u32,

    /// Number of CAS hits
    pub cas_hits: u32,

    /// Number of CAS bad value errors
    pub cas_badval: u32,

    /// Number of authentication commands
    pub auth_cmds: u32,

    /// Number of authentication errors
    pub auth_errors: u32,

    /// Total bytes read
    pub bytes_read: u64,

    /// Total bytes written
    pub bytes_written: u64,

    /// Maximum bytes limit
    pub limit_maxbytes: u32,

    /// Whether accepting connections (1=yes, 0=no)
    pub accepting_conns: u32,

    /// Number of times listen was disabled
    pub listen_disabled_num: u32,

    /// Number of threads
    pub threads: u32,

    /// Number of connection yields
    pub conn_yields: u32,

    /// Current bytes used
    pub bytes: u64,

    /// Current number of items
    pub curr_items: u32,

    /// Total number of items
    pub total_items: u32,

    /// Number of evictions
    pub evictions: u32,
}

/// HTTP Counters - Format (0,2201)
///
/// HTTP performance counters
///
/// # XDR Definition ([sFlow HTTP](https://sflow.org/sflow_http.txt))
///
/// ```text
/// /* HTTP counters */
/// /* opaque = counter_data; enterprise = 0; format = 2201 */
/// struct http_counters {
///   unsigned int method_option_count;
///   unsigned int method_get_count;
///   unsigned int method_head_count;
///   unsigned int method_post_count;
///   unsigned int method_put_count;
///   unsigned int method_delete_count;
///   unsigned int method_trace_count;
///   unsigned int method_connect_count;
///   unsigned int method_other_count;
///   unsigned int status_1XX_count;
///   unsigned int status_2XX_count;
///   unsigned int status_3XX_count;
///   unsigned int status_4XX_count;
///   unsigned int status_5XX_count;
///   unsigned int status_other_count;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HttpCounters {
    /// OPTIONS method count
    pub method_option_count: u32,

    /// GET method count
    pub method_get_count: u32,

    /// HEAD method count
    pub method_head_count: u32,

    /// POST method count
    pub method_post_count: u32,

    /// PUT method count
    pub method_put_count: u32,

    /// DELETE method count
    pub method_delete_count: u32,

    /// TRACE method count
    pub method_trace_count: u32,

    /// CONNECT method count
    pub method_connect_count: u32,

    /// Other method count
    pub method_other_count: u32,

    /// 1XX status code count (spec: status_1XX_count)
    pub status_1xx_count: u32,

    /// 2XX status code count (spec: status_2XX_count)
    pub status_2xx_count: u32,

    /// 3XX status code count (spec: status_3XX_count)
    pub status_3xx_count: u32,

    /// 4XX status code count (spec: status_4XX_count)
    pub status_4xx_count: u32,

    /// 5XX status code count (spec: status_5XX_count)
    pub status_5xx_count: u32,

    /// Other status code count
    pub status_other_count: u32,
}

/// App Operations - Format (0,2202)
///
/// Count of operations by status code
///
/// # XDR Definition ([sFlow Application](https://sflow.org/sflow_application.txt))
///
/// ```text
/// /* Application counters */
/// /* opaque = counter_data; enterprise = 0; format = 2202 */
///
/// struct app_operations {
///     application application;
///     unsigned int success;
///     unsigned int other;
///     unsigned int timeout;
///     unsigned int internal_error;
///     unsigned int bad_request;
///     unsigned int forbidden;
///     unsigned int too_large;
///     unsigned int not_implemented;
///     unsigned int not_found;
///     unsigned int unavailable;
///     unsigned int unauthorized;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AppOperations {
    /// Application identifier
    pub application: String,

    /// Successful operations
    pub success: u32,

    /// Other status
    pub other: u32,

    /// Timeout
    pub timeout: u32,

    /// Internal error
    pub internal_error: u32,

    /// Bad request
    pub bad_request: u32,

    /// Forbidden
    pub forbidden: u32,

    /// Too large
    pub too_large: u32,

    /// Not implemented
    pub not_implemented: u32,

    /// Not found
    pub not_found: u32,

    /// Unavailable
    pub unavailable: u32,

    /// Unauthorized
    pub unauthorized: u32,
}

/// App Resources - Format (0,2203)
///
/// Application resource usage
///
/// # XDR Definition ([sFlow Application](https://sflow.org/sflow_application.txt))
///
/// ```text
/// /* Application resources */
/// /* opaque = counter_data; enterprise = 0; format = 2203 */
///
/// struct app_resources {
///     unsigned int user_time;   /* user time (ms) */
///     unsigned int system_time; /* system time (ms) */
///     unsigned hyper mem_used;  /* memory used in bytes */
///     unsigned hyper mem_max;   /* max memory in bytes */
///     unsigned int fd_open;     /* open file descriptors */
///     unsigned int fd_max;      /* max file descriptors */
///     unsigned int conn_open;   /* open network connections */
///     unsigned int conn_max;    /* max network connections */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AppResources {
    /// User time in milliseconds
    pub user_time: u32,

    /// System time in milliseconds
    pub system_time: u32,

    /// Memory used in bytes
    pub mem_used: u64,

    /// Maximum memory in bytes
    pub mem_max: u64,

    /// Number of open file descriptors
    pub fd_open: u32,

    /// Maximum number of file descriptors
    pub fd_max: u32,

    /// Number of open connections
    pub conn_open: u32,

    /// Maximum number of connections
    pub conn_max: u32,
}

/// Memcache Counters - Format (0,2204)
///
/// Memcache server performance counters
///
/// # XDR Definition ([sFlow Memcache](https://sflow.org/sflow_memcache.txt))
///
/// ```text
/// /* Memcache counters */
/// /* See Memcached protocol.txt */
/// /* opaque = counter_data; enterprise = 0; format = 2204 */
///
/// struct memcache_counters {
///   unsigned int cmd_set;
///   unsigned int cmd_touch;
///   unsigned int cmd_flush;
///   unsigned int get_hits;
///   unsigned int get_misses;
///   unsigned int delete_hits;
///   unsigned int delete_misses;
///   unsigned int incr_hits;
///   unsigned int incr_misses;
///   unsigned int decr_hits;
///   unsigned int decr_misses;
///   unsigned int cas_hits;
///   unsigned int cas_misses;
///   unsigned int cas_badval;
///   unsigned int auth_cmds;
///   unsigned int auth_errors;
///   unsigned int threads;
///   unsigned int conn_yields;
///   unsigned int listen_disabled_num;
///   unsigned int curr_connections;
///   unsigned int rejected_connections;
///   unsigned int total_connections;
///   unsigned int connection_structures;
///   unsigned int evictions;
///   unsigned int reclaimed;
///   unsigned int curr_items;
///   unsigned int total_items;
///   unsigned hyper bytes_read;
///   unsigned hyper bytes_written;
///   unsigned hyper bytes;
///   unsigned hyper limit_maxbytes;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MemcacheCounters {
    /// Number of set commands
    pub cmd_set: u32,

    /// Number of touch commands
    pub cmd_touch: u32,

    /// Number of flush commands
    pub cmd_flush: u32,

    /// Number of get hits
    pub get_hits: u32,

    /// Number of get misses
    pub get_misses: u32,

    /// Number of delete hits
    pub delete_hits: u32,

    /// Number of delete misses
    pub delete_misses: u32,

    /// Number of increment hits
    pub incr_hits: u32,

    /// Number of increment misses
    pub incr_misses: u32,

    /// Number of decrement hits
    pub decr_hits: u32,

    /// Number of decrement misses
    pub decr_misses: u32,

    /// Number of CAS hits
    pub cas_hits: u32,

    /// Number of CAS misses
    pub cas_misses: u32,

    /// Number of CAS bad value errors
    pub cas_badval: u32,

    /// Number of authentication commands
    pub auth_cmds: u32,

    /// Number of authentication errors
    pub auth_errors: u32,

    /// Number of threads
    pub threads: u32,

    /// Number of connection yields
    pub conn_yields: u32,

    /// Number of times listen was disabled
    pub listen_disabled_num: u32,

    /// Current number of connections
    pub curr_connections: u32,

    /// Number of rejected connections
    pub rejected_connections: u32,

    /// Total number of connections
    pub total_connections: u32,

    /// Number of connection structures
    pub connection_structures: u32,

    /// Number of evictions
    pub evictions: u32,

    /// Number of reclaimed items
    pub reclaimed: u32,

    /// Current number of items
    pub curr_items: u32,

    /// Total number of items
    pub total_items: u32,

    /// Total bytes read
    pub bytes_read: u64,

    /// Total bytes written
    pub bytes_written: u64,

    /// Current bytes used
    pub bytes: u64,

    /// Maximum bytes limit
    pub limit_maxbytes: u64,
}

/// App Workers - Format (0,2206)
///
/// Application worker thread/process statistics
///
/// # XDR Definition ([sFlow Application](https://sflow.org/sflow_application.txt))
///
/// ```text
/// /* Application workers */
/// /* opaque = counter_data; enterprise = 0; format = 2206 */
///
/// struct app_workers {
///     unsigned int workers_active; /* number of active workers */
///     unsigned int workers_idle;   /* number of idle workers */
///     unsigned int workers_max;    /* max number of workers */
///     unsigned int req_delayed;    /* requests delayed */
///     unsigned int req_dropped;    /* requests dropped */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AppWorkers {
    /// Number of active workers
    pub workers_active: u32,

    /// Number of idle workers
    pub workers_idle: u32,

    /// Maximum number of workers
    pub workers_max: u32,

    /// Number of delayed requests
    pub req_delayed: u32,

    /// Number of dropped requests
    pub req_dropped: u32,
}

/// OVS DP Stats - Format (0,2207)
///
/// Open vSwitch data path statistics
///
/// # XDR Definition ([sFlow Discussion](http://blog.sflow.com/2015/01/open-vswitch-performance-monitoring.html))
///
/// ```text
/// /* Open vSwitch data path statistics */
/// /* see datapath/datapath.h */
/// /* opaque = counter_data; enterprise = 0; format = 2207 */
/// struct ovs_dp_stats {
///     unsigned int hits;
///     unsigned int misses;
///     unsigned int lost;
///     unsigned int mask_hits;
///     unsigned int flows;
///     unsigned int masks;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OvsDpStats {
    /// Number of flow table hits
    pub hits: u32,

    /// Number of flow table misses
    pub misses: u32,

    /// Number of lost packets
    pub lost: u32,

    /// Number of mask cache hits
    pub mask_hits: u32,

    /// Number of flows in the data path
    pub flows: u32,

    /// Number of masks in the data path
    pub masks: u32,
}

/// Energy Consumption - Format (0,3000)
///
/// Power consumption and energy metrics
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/gN3nxSi2SBs))
///
/// ```text
/// /* Energy consumption */
/// /* opaque = counter_data; enterprise = 0; format = 3000 */
///
/// struct energy {
///     unsigned int voltage;      /* measured in mV
///                                   unknown = 4,294,976,295 */
///     unsigned int current;      /* measured in mA
///                                   unknown = 4,294,976,295 */
///     unsigned int real_power;   /* measured in mW
///                                   unknown = 4,294,976,295 */
///     int power_factor;          /* power factor
///                                   (expressed in 100ths of a
///                                   percent)
///                                   -10000 to 10000 for AC power
///                                   -2,147,483,647 for unknown AC
///                                   power factor
///                                   2,147,483,647 for DC power */
///     unsigned int energy;       /* energy in millijoules
///                                   unknown = 4,294,976,295 */
///     unsigned int errors;       /* count of power exceptions,
///                                   including:
///                                   over/under voltage
///                                   over current
///                                   over power
///                                   unknown = 4,294,976,295 */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Energy {
    /// Voltage measured in millivolts (unknown = 4,294,976,295)
    pub voltage: u32,

    /// Current measured in milliamps (unknown = 4,294,976,295)
    pub current: u32,

    /// Real power measured in milliwatts (unknown = 4,294,976,295)
    pub real_power: u32,

    /// Power factor expressed in 100ths of a percent
    /// - Range: -10000 to 10000 for AC power
    /// - -2,147,483,647 for unknown AC power factor
    /// - 2,147,483,647 for DC power
    pub power_factor: i32,

    /// Energy in millijoules (unknown = 4,294,976,295)
    pub energy: u32,

    /// Count of power exceptions (over/under voltage, over current, over power)
    /// (unknown = 4,294,976,295)
    pub errors: u32,
}

/// Temperature - Format (0,3001)
///
/// Temperature sensor readings
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/gN3nxSi2SBs))
///
/// ```text
/// /* Temperature */
/// /* opaque = counter_data; enterprise = 0; format = 3001 */
///
/// struct temperature {
///     int minimum;        /* temperature reading from coolest
///                            thermometer
///                            expressed in tenths of a degree Celsius
///                            */
///     int maximum;        /* temperature reading from hottest
///                            thermometer
///                            expressed in tenths of a degree Celsius
///                            */
///     unsigned int errors; /* count of temperature exceptions */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Temperature {
    /// Temperature reading from coolest thermometer in tenths of a degree Celsius
    pub minimum: i32,

    /// Temperature reading from hottest thermometer in tenths of a degree Celsius
    pub maximum: i32,

    /// Count of temperature exceptions
    pub errors: u32,
}

/// Humidity - Format (0,3002)
///
/// Relative humidity measurement
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/gN3nxSi2SBs))
///
/// ```text
/// /* Humidity */
/// /* opaque = counter_data; enterprise = 0; format 3002 */
///
/// struct humidity {
///     int relative; /* relative humidity expressed as a percentage */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Humidity {
    /// Relative humidity expressed as a percentage
    pub relative: i32,
}

/// Fans - Format (0,3003)
///
/// Cooling fan statistics
///
/// # XDR Definition ([sFlow Discussion](https://groups.google.com/g/sflow/c/gN3nxSi2SBs))
///
/// ```text
/// /* Cooling */
/// /* opaque = counter_data; enterprise = 0; format=3003 */
///
/// struct fans {
///     unsigned int total;  /* total fans */
///     unsigned int failed; /* failed fans */
///     unsigned int speed;  /* average fan speed expressed in percent */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Fans {
    /// Total number of fans
    pub total: u32,

    /// Number of failed fans
    pub failed: u32,

    /// Average fan speed expressed as a percentage
    pub speed: u32,
}

/// Broadcom Device Buffer Utilization - Format (4413,1)
///
/// Device level buffer utilization statistics from Broadcom switch ASICs
///
/// # XDR Definition ([sFlow Broadcom Buffers](https://sflow.org/bv-sflow.txt))
///
/// ```text
/// /* Device level buffer utilization */
/// /* buffers_used metrics represent peak since last export */
/// /* opaque = counter_data; enterprise = 4413; format = 1 */
/// struct bst_device_buffers {
///   percentage uc_pc;  /* unicast buffers percentage utilization */
///   percentage mc_pc;  /* multicast buffers percentage utilization */
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BroadcomDeviceBuffers {
    /// Unicast buffers percentage utilization (in hundredths of a percent, e.g., 100 = 1%)
    pub uc_pc: i32,

    /// Multicast buffers percentage utilization (in hundredths of a percent, e.g., 100 = 1%)
    pub mc_pc: i32,
}

/// Broadcom Port Buffer Utilization - Format (4413,2)
///
/// Port level buffer utilization statistics from Broadcom switch ASICs
///
/// # XDR Definition ([sFlow Broadcom Buffers](https://sflow.org/bv-sflow.txt))
///
/// ```text
/// /* Port level buffer utilization */
/// /* buffers_used metrics represent peak buffers used since last export */
/// /* opaque = counter_data; enterprise = 4413; format = 2 */
/// struct bst_port_buffers {
///   percentage ingress_uc_pc;         /* ingress unicast buffers utilization */
///   percentage ingress_mc_pc;         /* ingress multicast buffers utilization */
///   percentage egress_uc_pc;          /* egress unicast buffers utilization */
///   percentage egress_mc_pc;          /* egress multicast buffers utilization */
///   percentage egress_queue_uc_pc<8>; /* per egress queue unicast buffers utilization */
///   percentage egress_queue_mc_pc<8>; /* per egress queue multicast buffers utilization*/
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BroadcomPortBuffers {
    /// Ingress unicast buffers percentage utilization (in hundredths of a percent)
    pub ingress_uc_pc: i32,

    /// Ingress multicast buffers percentage utilization (in hundredths of a percent)
    pub ingress_mc_pc: i32,

    /// Egress unicast buffers percentage utilization (in hundredths of a percent)
    pub egress_uc_pc: i32,

    /// Egress multicast buffers percentage utilization (in hundredths of a percent)
    pub egress_mc_pc: i32,

    /// Per egress queue unicast buffers percentage utilization (up to 8 queues)
    pub egress_queue_uc_pc: Vec<i32>,

    /// Per egress queue multicast buffers percentage utilization (up to 8 queues)
    pub egress_queue_mc_pc: Vec<i32>,
}

/// Broadcom Switch ASIC Table Utilization - Format (4413,3)
///
/// Table utilization statistics from Broadcom switch ASICs
///
/// # XDR Definition ([sFlow Broadcom Tables](https://sflow.org/sflow_broadcom_tables.txt))
///
/// ```text
/// /* Table utilizations */
/// /* utilization of ASIC hardware tables */
/// /* opaque = counter_data; enterprise = 4413; format = 3 */
/// struct hw_tables {
///   unsigned int host_entries;
///   unsigned int host_entries_max;
///   unsigned int ipv4_entries;
///   unsigned int ipv4_entries_max;
///   unsigned int ipv6_entries;
///   unsigned int ipv6_entries_max;
///   unsigned int ipv4_ipv6_entries;
///   unsigned int ipv6_ipv6_entries_max;
///   unsigned int long_ipv6_entries;
///   unsigned int long_ipv6_entries_max;
///   unsigned int total_routes;
///   unsigned int total_routes_max;
///   unsigned int ecmp_nexthops;
///   unsigned int ecmp_nexthops_max;
///   unsigned int mac_entries;
///   unsigned int mac_entries_max;
///   unsigned int ipv4_neighbors;
///   unsigned int ipv6_neighbors;
///   unsigned int ipv4_routes;
///   unsigned int ipv6_routes;
///   unsigned int acl_ingress_entries;
///   unsigned int acl_ingress_entries_max;
///   unsigned int acl_ingress_counters;
///   unsigned int acl_ingress_counters_max;
///   unsigned int acl_ingress_meters;
///   unsigned int acl_ingress_meters_max;
///   unsigned int acl_ingress_slices;
///   unsigned int acl_ingress_slices_max;
///   unsigned int acl_egress_entries;
///   unsigned int acl_egress_entries_max;
///   unsigned int acl_egress_counters;
///   unsigned int acl_egress_counters_max;
///   unsigned int acl_egress_meters;
///   unsigned int acl_egress_meters_max;
///   unsigned int acl_egress_slices;
///   unsigned int acl_egress_slices_max;
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BroadcomTables {
    /// Number of host table entries
    pub host_entries: u32,

    /// Maximum number of host table entries
    pub host_entries_max: u32,

    /// Number of IPv4 routing table entries
    pub ipv4_entries: u32,

    /// Maximum number of IPv4 routing table entries
    pub ipv4_entries_max: u32,

    /// Number of IPv6 routing table entries
    pub ipv6_entries: u32,

    /// Maximum number of IPv6 routing table entries
    pub ipv6_entries_max: u32,

    /// Number of IPv4/IPv6 routing table entries
    pub ipv4_ipv6_entries: u32,

    /// Maximum number of IPv6/IPv6 routing table entries
    pub ipv6_ipv6_entries_max: u32,

    /// Number of long IPv6 routing table entries
    pub long_ipv6_entries: u32,

    /// Maximum number of long IPv6 routing table entries
    pub long_ipv6_entries_max: u32,

    /// Total number of routes
    pub total_routes: u32,

    /// Maximum total number of routes
    pub total_routes_max: u32,

    /// Number of ECMP nexthops
    pub ecmp_nexthops: u32,

    /// Maximum number of ECMP nexthops
    pub ecmp_nexthops_max: u32,

    /// Number of MAC table entries
    pub mac_entries: u32,

    /// Maximum number of MAC table entries
    pub mac_entries_max: u32,

    /// Number of IPv4 neighbors
    pub ipv4_neighbors: u32,

    /// Number of IPv6 neighbors
    pub ipv6_neighbors: u32,

    /// Number of IPv4 routes
    pub ipv4_routes: u32,

    /// Number of IPv6 routes
    pub ipv6_routes: u32,

    /// Number of ingress ACL entries
    pub acl_ingress_entries: u32,

    /// Maximum number of ingress ACL entries
    pub acl_ingress_entries_max: u32,

    /// Number of ingress ACL counters
    pub acl_ingress_counters: u32,

    /// Maximum number of ingress ACL counters
    pub acl_ingress_counters_max: u32,

    /// Number of ingress ACL meters
    pub acl_ingress_meters: u32,

    /// Maximum number of ingress ACL meters
    pub acl_ingress_meters_max: u32,

    /// Number of ingress ACL slices
    pub acl_ingress_slices: u32,

    /// Maximum number of ingress ACL slices
    pub acl_ingress_slices_max: u32,

    /// Number of egress ACL entries
    pub acl_egress_entries: u32,

    /// Maximum number of egress ACL entries
    pub acl_egress_entries_max: u32,

    /// Number of egress ACL counters
    pub acl_egress_counters: u32,

    /// Maximum number of egress ACL counters
    pub acl_egress_counters_max: u32,

    /// Number of egress ACL meters
    pub acl_egress_meters: u32,

    /// Maximum number of egress ACL meters
    pub acl_egress_meters_max: u32,

    /// Number of egress ACL slices
    pub acl_egress_slices: u32,

    /// Maximum number of egress ACL slices
    pub acl_egress_slices_max: u32,
}

/// NVIDIA GPU Statistics - Format (5703,1)
///
/// GPU performance metrics from NVIDIA Management Library (NVML)
///
/// # XDR Definition ([sFlow NVML](https://sflow.org/sflow_nvml.txt))
///
/// ```text
/// /* NVIDIA GPU statistics */
/// /* opaque = counter_data; enterprise = 5703; format = 1 */
/// struct nvidia_gpu {
///   unsigned int device_count; /* see nvmlDeviceGetCount */
///   unsigned int processes;    /* see nvmlDeviceGetComputeRunningProcesses */
///   unsigned int gpu_time;     /* total milliseconds in which one or more
///                                 kernels was executing on GPU
///                                 sum across all devices */
///   unsigned int mem_time;     /* total milliseconds during which global device
///                                 memory was being read/written
///                                 sum across all devices */
///   unsigned hyper mem_total;  /* sum of framebuffer memory across devices
///                                 see nvmlDeviceGetMemoryInfo */
///   unsigned hyper mem_free;   /* sum of free framebuffer memory across devices
///                                 see nvmlDeviceGetMemoryInfo */
///   unsigned int ecc_errors;   /* sum of volatile ECC errors across devices
///                                 see nvmlDeviceGetTotalEccErrors */
///   unsigned int energy;       /* sum of millijoules across devices
///                                 see nvmlDeviceGetPowerUsage */
///   unsigned int temperature;  /* maximum temperature in degrees Celsius
///                                 across devices
///                                 see nvmlDeviceGetTemperature */
///   unsigned int fan_speed;    /* maximum fan speed in percent across devices
///                                 see nvmlDeviceGetFanSpeed */
/// }
/// ```
///
/// **ERRATUM:** The specification uses a comma instead of a semicolon in the format comment
/// (`enterprise = 5703, format=1` should be `enterprise = 5703; format = 1`), which is
/// inconsistent with all other sFlow specifications. The corrected version is shown above.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct NvidiaGpu {
    /// Number of GPU devices
    pub device_count: u32,

    /// Number of running compute processes
    pub processes: u32,

    /// Total GPU time in milliseconds (sum across all devices)
    pub gpu_time: u32,

    /// Total memory access time in milliseconds (sum across all devices)
    pub mem_time: u32,

    /// Total framebuffer memory in bytes (sum across all devices)
    pub mem_total: u64,

    /// Free framebuffer memory in bytes (sum across all devices)
    pub mem_free: u64,

    /// Sum of volatile ECC errors across all devices
    pub ecc_errors: u32,

    /// Total energy consumption in millijoules (sum across all devices)
    pub energy: u32,

    /// Maximum temperature in degrees Celsius across all devices
    pub temperature: u32,

    /// Maximum fan speed in percent across all devices
    pub fan_speed: u32,
}