tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/hli_v1/indices/connection_group/tcp.py

@@ -0,0 +1,314 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_CLEAR_POST_STAT,
+    P4G_TCP_RTT_VALUE,
+    P4G_TCP_STATE_CURRENT,
+    P4G_TCP_STATE_TOTAL,
+    P4G_TCP_STATE_RATE,
+    P4G_TCP_RX_PAYLOAD_COUNTERS,
+    P4G_TCP_TX_PAYLOAD_COUNTERS,
+    P4G_TCP_RETRANSMIT_COUNTERS,
+    P4G_TCP_ERROR_COUNTERS,
+    P4G_TCP_MSS_TYPE,
+    P4G_TCP_MSS_MINMAX,
+    P4G_TCP_MSS_VALUE,
+    P4G_TCP_WINDOW_SIZE,
+    P4G_TCP_DUP_THRES,
+    P4G_TCP_SYN_RTO,
+    P4G_TCP_RTO,
+    P4G_TCP_CONGESTION_MODE,
+    P4G_TCP_WINDOW_SCALING,
+    P4G_TCP_RTO_MINMAX,
+    P4G_TCP_RTO_PROLONGED_MODE,
+    P4G_TCP_ICWND_CALC_METHOD,
+    P4G_TCP_ISSTHRESH,
+    P4G_TCP_ACK_FREQUENCY,
+    P4G_TCP_ACK_TIMEOUT,
+    P4G_TCP_ESTABLISH_HIST,
+    P4G_TCP_CLOSE_HIST,
+    P4G_TCP_RX_TOTAL_BYTES_HIST,
+    P4G_TCP_RX_GOOD_BYTES_HIST,
+    P4G_TCP_TX_TOTAL_BYTES_HIST,
+    P4G_TCP_TX_GOOD_BYTES_HIST,
+    P4G_TCP_RX_PACKET_COUNTERS,
+    P4G_TCP_TX_PACKET_COUNTERS,
+)
+
+
+class GAckTcp:
+    """TCP ACK configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.duplicate_thresholds = P4G_TCP_DUP_THRES(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_DUP_THRES
+        """
+        self.frequency = P4G_TCP_ACK_FREQUENCY(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ACK_FREQUENCY
+        """
+        self.timeout = P4G_TCP_ACK_TIMEOUT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ACK_TIMEOUT
+        """
+
+
+class GRetransmissionTimeoutTcp:
+    """TCP Retransmission Timeout configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.syn_value = P4G_TCP_SYN_RTO(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_SYN_RTO
+        """
+        self.value = P4G_TCP_RTO(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RTO
+        """
+        self.range_limits = P4G_TCP_RTO_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RTO_MINMAX
+        """
+        self.prolonged_mode = P4G_TCP_RTO_PROLONGED_MODE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RTO_PROLONGED_MODE
+        """
+
+
+class GStateCountersTcp:
+    """TCP State counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_TCP_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_STATE_CURRENT
+        """
+        self.total = P4G_TCP_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_STATE_TOTAL
+        """
+        self.rate = P4G_TCP_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_STATE_RATE
+        """
+
+
+class GMaxSegmentSize:
+    """TCP Max Segment Size Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_TCP_MSS_TYPE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_MSS_TYPE
+        """
+        self.range_limits = P4G_TCP_MSS_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_MSS_MINMAX
+        """
+        self.fixed_value = P4G_TCP_MSS_VALUE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_MSS_VALUE
+        """
+
+
+class GPacketCountersTcp:
+    """TCP Packet Counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TCP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RX_PACKET_COUNTERS
+        """
+        self.tx = P4G_TCP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_TX_PACKET_COUNTERS
+        """
+
+
+class GPayloadCountersTcp:
+    """TCP Payload Counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TCP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_TCP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GCountersTcp:
+    """TCP counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.retransmission = P4G_TCP_RETRANSMIT_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RETRANSMIT_COUNTERS
+        """
+        self.error = P4G_TCP_ERROR_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ERROR_COUNTERS
+        """
+        self.packet = GPacketCountersTcp(conn, module_id, port_id, group_idx)
+        """Packet counters"""
+        self.payload = GPayloadCountersTcp(conn, module_id, port_id, group_idx)
+        """Payload counters"""
+        self.state = GStateCountersTcp(conn, module_id, port_id, group_idx)
+        """State counters"""
+
+
+class GRxHistogramTcp:
+    """TCP RX Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.total_bytes = P4G_TCP_RX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RX_TOTAL_BYTES_HIST
+        """
+        self.good_bytes = P4G_TCP_RX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RX_GOOD_BYTES_HIST
+        """
+
+
+class GTxHistogramTcp:
+    """TCP TX Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.total_bytes = P4G_TCP_TX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_TX_TOTAL_BYTES_HIST
+        """
+        self.good_bytes = P4G_TCP_TX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_TX_GOOD_BYTES_HIST
+        """
+
+
+class GConnHistogramTcp:
+    """TCP Connection Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.establish_times = P4G_TCP_ESTABLISH_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ESTABLISH_HIST
+        """
+        self.close_times = P4G_TCP_CLOSE_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_CLOSE_HIST
+        """
+
+
+class GHistogramTcp:
+    """TCP histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.connection = GConnHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP Connection Histogram"""
+        self.rx = GRxHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP RX Histogram"""
+        self.tx = GTxHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP TX Histogram"""
+
+
+class GReceiverWindowTcp:
+    """TCP RWND Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.size = P4G_TCP_WINDOW_SIZE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_WINDOW_SIZE
+        """
+        self.scaling = P4G_TCP_WINDOW_SCALING(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_WINDOW_SCALING
+        """
+
+
+class GCongestionWindowTcp:
+    """TCP CWND Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.congestion_mode = P4G_TCP_CONGESTION_MODE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_CONGESTION_MODE
+        """
+        self.icwnd_calc_method = P4G_TCP_ICWND_CALC_METHOD(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ICWND_CALC_METHOD
+        """
+
+
+class GTcp:
+    """TCP Stack Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.clear_post_test_statistics = P4G_CLEAR_POST_STAT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_CLEAR_POST_STAT
+        """
+        self.rtt_value = P4G_TCP_RTT_VALUE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_RTT_VALUE
+        """
+        self.iss_treshold = P4G_TCP_ISSTHRESH(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TCP_ISSTHRESH
+        """
+        self.mss = GMaxSegmentSize(conn, module_id, port_id, group_idx)
+        """Max segment size config
+        
+        :type: GMaxSegmentSize
+        """
+        self.rto = GRetransmissionTimeoutTcp(conn, module_id, port_id, group_idx)
+        """Retransmission timeout config
+        
+        :type: GRetransmissionTimeoutTcp
+        """
+        self.ack = GAckTcp(conn, module_id, port_id, group_idx)
+        """ACK config
+        
+        :type: GAckTcp
+        """
+        self.rwnd = GReceiverWindowTcp(conn, module_id, port_id, group_idx)
+        """RWND config
+        
+        :type: GReceiverWindowTcp
+        """
+        self.cwnd = GCongestionWindowTcp(conn, module_id, port_id, group_idx)
+        """CWND config
+        
+        :type: GCongestionWindowTcp
+        """
+        self.counters = GCountersTcp(conn, module_id, port_id, group_idx)
+        """Counters.
+        
+        :type: GCountersTcp
+        """
+        self.histogram = GHistogramTcp(conn, module_id, port_id, group_idx)
+        """Histogram.
+        
+        :type: GHistogramTcp
+        """

xoa_driver/internals/hli_v1/indices/connection_group/tls.py

@@ -0,0 +1,198 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_TLS_ENABLE,
+    P4G_TLS_CIPHER_SUITES,
+    P4G_TLS_MAX_RECORD_SIZE,
+    P4G_TLS_CERTIFICATE_FILENAME,
+    P4G_TLS_PRIVATE_KEY_FILENAME,
+    P4G_TLS_DHPARAMS_FILENAME,
+    P4G_TLS_CLOSE_NOTIFY,
+    P4G_TLS_ALERT_WARNING_COUNTERS,
+    P4G_TLS_ALERT_FATAL_COUNTERS,
+    P4G_TLS_STATE_CURRENT,
+    P4G_TLS_STATE_TOTAL,
+    P4G_TLS_STATE_RATE,
+    P4G_TLS_RX_PAYLOAD_COUNTERS,
+    P4G_TLS_TX_PAYLOAD_COUNTERS,
+    P4G_TLS_RX_PAYLOAD_BYTES_HIST,
+    P4G_TLS_TX_PAYLOAD_BYTES_HIST,
+    P4G_TLS_HANDSHAKE_HIST,
+    P4G_TLS_SERVER_NAME,
+    P4G_TLS_PROTOCOL_VER,
+    P4G_TLS_MIN_REQ_PROTOCOL_VER,
+)
+
+
+class GCountersTlsState:
+    """TLS state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_TLS_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_STATE_CURRENT
+        """
+        self.total = P4G_TLS_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_STATE_TOTAL
+        """
+        self.rate = P4G_TLS_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_STATE_RATE
+        """
+
+
+class GCountersTlsAlert:
+    """TLS alert counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.warning = P4G_TLS_ALERT_WARNING_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_ALERT_WARNING_COUNTERS
+        """
+        self.fatal = P4G_TLS_ALERT_FATAL_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_ALERT_FATAL_COUNTERS
+        """
+
+
+class GCountersTlsPayload:
+    """TLS payload counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TLS_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_TLS_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GCountersTls:
+    """TLS counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.alert = GCountersTlsAlert(conn, module_id, port_id, group_idx)
+        """TLS alert counters"""
+        self.payload = GCountersTlsPayload(conn, module_id, port_id, group_idx)
+        """TLS payload counters"""
+        self.state = GCountersTlsState(conn, module_id, port_id, group_idx)
+        """TLS state counters"""
+
+
+class GHistogramTlsPayload:
+    """TLS payload histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx_bytes = P4G_TLS_RX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_RX_PAYLOAD_BYTES_HIST
+        """
+        self.tx_bytes = P4G_TLS_TX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_TX_PAYLOAD_BYTES_HIST
+        """
+
+
+class GHistogramTls:
+    """TLS histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.handshake = P4G_TLS_HANDSHAKE_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_HANDSHAKE_HIST
+        """
+        self.payload = GHistogramTlsPayload(conn, module_id, port_id, group_idx)
+        """TLS payload histogram"""
+
+
+class GProtocolTls:
+    """TLS protocol version"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.version = P4G_TLS_PROTOCOL_VER(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_PROTOCOL_VER
+        """
+        self.min_required_version = P4G_TLS_MIN_REQ_PROTOCOL_VER(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_MIN_REQ_PROTOCOL_VER
+        """
+
+
+class GFileTls:
+    """TLS certificate and key files"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.certificate_path = P4G_TLS_CERTIFICATE_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_CERTIFICATE_FILENAME
+        """
+        self.private_key_path = P4G_TLS_PRIVATE_KEY_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_PRIVATE_KEY_FILENAME
+        """
+        self.dhparams_path = P4G_TLS_DHPARAMS_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_DHPARAMS_FILENAME
+        """
+
+
+class GTls:
+    """TLS configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.enable = P4G_TLS_ENABLE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_ENABLE
+        """
+        self.server_name = P4G_TLS_SERVER_NAME(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_SERVER_NAME
+        """
+        self.close_notify = P4G_TLS_CLOSE_NOTIFY(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_CLOSE_NOTIFY
+        """
+        self.cipher_suites = P4G_TLS_CIPHER_SUITES(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_CIPHER_SUITES
+        """
+        self.max_record_size = P4G_TLS_MAX_RECORD_SIZE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_TLS_MAX_RECORD_SIZE
+        """
+        self.file = GFileTls(conn, module_id, port_id, group_idx)
+        """Cert and key file
+        
+        :type: GFileTls
+        """
+        self.protocol = GProtocolTls(conn, module_id, port_id, group_idx)
+        """Protocol version
+        
+        :type: GProtocolTls
+        """
+        self.counters = GCountersTls(conn, module_id, port_id, group_idx)
+        """Counters
+        
+        :type: GCountersTls
+        """
+        self.histogram = GHistogramTls(conn, module_id, port_id, group_idx)
+        """Histogram
+        
+        :type: GHistogramTls
+        """

xoa_driver/internals/hli_v1/indices/connection_group/udp.py

@@ -0,0 +1,133 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_UDP_PACKET_SIZE_TYPE,
+    P4G_UDP_PACKET_SIZE_MINMAX,
+    P4G_UDP_PACKET_SIZE_VALUE,
+    P4G_UDP_STATE_CURRENT,
+    P4G_UDP_STATE_TOTAL,
+    P4G_UDP_STATE_RATE,
+    P4G_UDP_RX_PAYLOAD_COUNTERS,
+    P4G_UDP_TX_PAYLOAD_COUNTERS,
+    P4G_UDP_RX_BYTES_HIST,
+    P4G_UDP_TX_BYTES_HIST,
+    P4G_UDP_RX_PACKET_COUNTERS,
+    P4G_UDP_TX_PACKET_COUNTERS,
+)
+
+
+class GHistogramUdp:
+    """UDP histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx_bytes = P4G_UDP_RX_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_RX_BYTES_HIST
+        """
+        self.tx_bytes = P4G_UDP_TX_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_TX_BYTES_HIST
+        """
+
+
+class GPayloadCountersUdp:
+    """UDP payload counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_UDP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_UDP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GPacketCountersUdp:
+    """UDP packet counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_UDP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_RX_PACKET_COUNTERS
+        """
+        self.tx = P4G_UDP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_TX_PACKET_COUNTERS
+        """
+
+
+class GCountersUdp:
+    """UDP counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.payload = GPayloadCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP payload counters"""
+        self.packet = GPacketCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP packet counters"""
+        self.state = GStateCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP state counters"""
+
+
+class GPacketSizeUdp:
+    """UDP packet size"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_UDP_PACKET_SIZE_TYPE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_PACKET_SIZE_TYPE
+        """
+        self.range_limits = P4G_UDP_PACKET_SIZE_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_PACKET_SIZE_MINMAX
+        """
+        self.value = P4G_UDP_PACKET_SIZE_VALUE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_PACKET_SIZE_VALUE
+        """
+
+
+class GStateCountersUdp:
+    """UDP state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_UDP_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_STATE_CURRENT
+        """
+        self.total = P4G_UDP_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_STATE_TOTAL
+        """
+        self.rate = P4G_UDP_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_UDP_STATE_RATE
+        """
+
+
+class GUdp:
+    """UDP configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.packet_size = GPacketSizeUdp(conn, module_id, port_id, group_idx)
+        """UDP packet size
+        
+        :type: GPacketSizeUdp
+        """
+        self.counters = GCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP counters
+        
+        :type: GCountersUdp
+        """
+        self.histogram = GHistogramUdp(conn, module_id, port_id, group_idx)
+        """UDP histogram
+        
+        :type: GHistogramUdp
+        """

xoa_driver/internals/hli_v1/indices/connection_group/user_state.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_USER_STATE_CURRENT,
+    P4G_USER_STATE_TOTAL,
+    P4G_USER_STATE_RATE,
+)
+
+
+class GUserState:
+    """User state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_USER_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_USER_STATE_CURRENT
+        """
+        self.total = P4G_USER_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_USER_STATE_TOTAL
+        """
+        self.rate = P4G_USER_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_USER_STATE_RATE
+        """