module Cisco-IOS-XE-appqoe-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-appqoe-oper";

    prefix appqoe-xe-oper;

    import Cisco-IOS-XE-appqoe-types {
      prefix appqoe-types-ios-xe;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Application Quality of Experience (APPQOE) operational data.
     Copyright (c) 2020-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-07-01" {
      description
        "- Added support for SPPI and NAT stats
       - Added support for AppQoE sub service status
       - Updated infra statistics";
      reference
        "1.1.0";

    }

    revision "2020-11-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "1.1.0";
    cisco-semver:module-version "1.0.0";

    typedef appqoe-rm-status {
      type enumeration {
        enum "status-green" {
          value 0;
          description "RM Status is GREEN";
        }
        enum "status-yellow" {
          value 1;
          description "RM Status is YELLOW";
        }
      }
      description "APPQOE RM status";
    }

    typedef bbr-state {
      type enumeration {
        enum "bbr-startup" {
          value 0;
          description "Startup state";
        }
        enum "bbr-drain" {
          value 1;
          description "Drain state";
        }
        enum "probertt" {
          value 2;
          description
            "Probe Round Trip Time (RTT) state";
        }
        enum "idle-exit" {
          value 3;
          description "Exit Idle state";
        }
        enum "bbr-probebw" {
          value 4;
          description
            "Probe Bandwidth state";
        }
        enum "sub-drain" {
          value 5;
          description "Sub drain state";
        }
        enum "sub-gain" {
          value 6;
          description "Sub gain state";
        }
        enum "sub-level" {
          value 7;
          description "Sub level state";
        }
      }
      description
        "Bottleneck Bandwidth and Round-trip propagation time (BBR) States";
    }

    typedef state-tran {
      type enumeration {
        enum "startup-to-drain" {
          value 0;
          description
            "Startup to Drain state";
        }
        enum "startup-to-probebw" {
          value 1;
          description
            "Startup to Probe Bandwidth state";
        }
        enum "startup-to-probertt" {
          value 2;
          description
            "Startup to Probe RTT state";
        }
        enum "drain-to-probebw" {
          value 3;
          description
            "Drain to Probe Bandwidth state";
        }
        enum "probe-to-probertt" {
          value 4;
          description
            "Probe Bandwidth to Probe RTT state";
        }
        enum "probertt-to-startup" {
          value 5;
          description
            "Probe RTT to Startup state";
        }
        enum "probertt-probebw" {
          value 6;
          description
            "Probe RTT to Probe Bandwidth state";
        }
        enum "idleexit-to-probebw" {
          value 7;
          description
            "Idle Exit to Probe Bandwidth state";
        }
      }
      description "BBR state transitions";
    }

    typedef timer-source {
      type enumeration {
        enum "wrong-timer" {
          value 0;
          description
            "No. of times HPTS timer wrongly started";
        }
        enum "timeout-persist" {
          value 1;
          description
            "No. of times persistent timer started";
        }
        enum "timeout-keepalive" {
          value 2;
          description
            "No. of times keepalive timer started";
        }
        enum "init" {
          value 3;
          description
            "HPTS timer started during connection initialization";
        }
        enum "do-segment-unlock1" {
          value 4;
          description
            "HPTS timer started after receiving the segment";
        }
        enum "do-segment-unlock2" {
          value 5;
          description
            "HPTS timer started after receiving the segment and more data
           is available to send";
        }
        enum "output-wtime" {
          value 6;
          description
            "HPTS timer started without transmitted data";
        }
        enum "output-wtime-emsgsize" {
          value 7;
          description
            "HPTS timer started due to memory exhaustion";
        }
        enum "output-wtime-default" {
          value 8;
          description
            "HPTS timer started as BBR failed to send segment due to unknown reason";
        }
        enum "output-wtime-enobufs" {
          value 9;
          description
            "HPTS timer started after transmitting the data";
        }
      }
      description
        "High Precision timer System (HPTS) Timer started";
    }

    typedef bbr-slot {
      type enumeration {
        enum "slot-0" {
          value 0;
          description
            "Pacing delay is equal to 0";
        }
        enum "slot-1-5" {
          value 1;
          description
            "Pacing delay is equal and greater than 1 and
           less than and equal to 5";
        }
        enum "slot-6-10" {
          value 2;
          description
            "Pacing delay is greater than 5 and less than equal to 10";
        }
        enum "slot-11-20" {
          value 3;
          description
            "Pacing delay is greater than 10 and less than equal to 20";
        }
        enum "slot-21-50" {
          value 4;
          description
            "Pacing delay is greater than 20 and less than equal to 50";
        }
        enum "slot-51-100" {
          value 5;
          description
            "Pacing delay is greater than 50 and less than equal to 100";
        }
        enum "slot-101-500" {
          value 6;
          description
            "Pacing delay is greater than 100 and less than equal to 500";
        }
        enum "slot-501-1000" {
          value 7;
          description
            "Pacing delay is greater than 500 and less than equal to 1000";
        }
        enum "slot-gt-1us" {
          value 8;
          description
            "Pacing delay Greater than 1000";
        }
      }
      description "Pacing Delay (in us)";
    }

    typedef rem-timer {
      type enumeration {
        enum "rem-wrong-timer" {
          value 0;
          description
            "HPTS timer stopped as it is wrongly started";
        }
        enum "cancel-timer" {
          value 1;
          description "HPTS timer cancelled";
        }
        enum "rem-timer-exit-persist" {
          value 2;
          description
            "HPTS timer stopped due to persistent timeout";
        }
        enum "rem-timer-seg-unlock" {
          value 3;
          description
            "HPTS timer stopped once segment is received";
        }
        enum "rem-timer-pace-pkt" {
          value 4;
          description
            "HPTS timer stopped before transmitting the segment";
        }
        enum "rem-timer-early-state-exempt" {
          value 5;
          description
            "HPTS timer stopped if running before connection establishment";
        }
        enum "rem-timer-delay-exceed" {
          value 6;
          description
            "HPTS timer stopped due to delayed expiry.";
        }
        enum "rem-timer-connection-closed" {
          value 7;
          description
            "HPTS timer stopped due to connection termination";
        }
      }
      description "HPTS Timer Stopped";
    }

    typedef bbr-bw {
      type enumeration {
        enum "bw-lt-1kbps" {
          value 0;
          description
            "Bandwidth is less than 1 KBps";
        }
        enum "bw-1-250kbps" {
          value 1;
          description
            "Bandwidth is greater than 1 KBps and less than equal to 250 KBps";
        }
        enum "bw-251-500kbps" {
          value 2;
          description
            "Bandwidth is greater than 250 KBps and less than equal to 500 KBps";
        }
        enum "bw-500-1mbps" {
          value 3;
          description
            "Bandwidth is greater than 500 KBps and less than equal to 1 MBps";
        }
        enum "bw-1-2mbps" {
          value 4;
          description
            "Bandwidth is greater than 1 MBps and less than equal to 2 MBps";
        }
        enum "bw-2-5mbps" {
          value 5;
          description
            "Bandwidth is greater than 2 MBps and less than equal to 5 MBps";
        }
        enum "bw-5-10mbps" {
          value 6;
          description
            "Bandwidth is greater than 5 MBps and less than equal to 10 MBps";
        }
        enum "bw-gt-10mbps" {
          value 7;
          description
            "Bandwidth is greater than 10 MBps";
        }
      }
      description "Bandwidth Distribution";
    }

    typedef bbr-rtt {
      type enumeration {
        enum "rtt-lt-1ms" {
          value 0;
          description
            "RTT is less than 1 milliseconds";
        }
        enum "rtt-1ms" {
          value 1;
          description
            "RTT is equals 1 milliseconds";
        }
        enum "rtt-1-50ms" {
          value 2;
          description
            "RTT is greater than 1 and less than equal to 50 milliseconds";
        }
        enum "rtt-51-100ms" {
          value 3;
          description
            "RTT is greater than 1 and less than equal to 50 milliseconds";
        }
        enum "rtt-101-150ms" {
          value 4;
          description
            "RTT is greater than 1 and less than equal to 50 milliseconds";
        }
        enum "rtt-151-200ms" {
          value 5;
          description
            "RTT is greater than 1 and less than equal to 50 milliseconds";
        }
        enum "rtt-gt-200ms" {
          value 6;
          description
            "RTT is greater than 200 milliseconds";
        }
      }
      description
        "Round Trip Time (RTT) of TCP segments (in milliseconds)";
    }

    typedef tcp-proxy-ebp-service-id {
      type enumeration {
        enum "ebp-notused-id" {
          value 0;
          description
            "TCP PROXY EBP identifier not used";
        }
        enum "ebp-htx-ssl-id" {
          value 1;
          description
            "TCP PROXY EBP TCP SSL identifier";
        }
        enum "ebp-dre-id" {
          value 2;
          description
            "TCP PROXY EBP DRE identifier";
        }
      }
      description
        "Elastic Buffer Pool (EBP) service identifier";
    }

    typedef sipc-service-id {
      type enumeration {
        enum "sipc-notused-id" {
          value 0;
          description
            "SIPC identifier not used";
        }
        enum "sipc-server-id" {
          value 1;
          description
            "SIPC server identifier";
        }
        enum "sipc-dre-id" {
          value 2;
          description
            "Identifier used for communication between with DRE over SIPC";
        }
        enum "sipc-utd-id" {
          value 3;
          description
            "Identifier used for communication with first instance of UTD over SIPC";
        }
        enum "sipc-utd-1-id" {
          value 4;
          description
            "Identifier used for communication with second instance of UTD over SIPC";
        }
        enum "sipc-utd-2-id" {
          value 5;
          description
            "Identifier used for communication with third instance of UTD over SIPC";
        }
        enum "sipc-utd-3-id" {
          value 6;
          description
            "Identifier used for communication with fourth instance of UTD over SIPC";
        }
        enum "sipc-utd-4-id" {
          value 7;
          description
            "Identifier used for communication with fifth instance of UTD over SIPC";
        }
        enum "sipc-utd-5-id" {
          value 8;
          description
            "Identifier used for communication with sixth instance of UTD over SIPC";
        }
      }
      description "SIPC service identifier";
    }

    typedef sipc-fifo-type {
      type enumeration {
        enum "sipc-fifo-type-normal" {
          value 0;
          description
            "SIPC FIFO type is normal";
        }
        enum "sipc-fifo-type-elastic" {
          value 1;
          description
            "SIPC FIFO type is elastic";
        }
      }
      description "SIPC FIFO type";
    }

    typedef sipc-pause-status {
      type enumeration {
        enum "appqoe-sipc-fifo-nopause" {
          value 0;
          description
            "SIPC FIFO is not paused";
        }
        enum "appqoe-sipc-fifo-paused" {
          value 1;
          description "SIPC FIFO is paused";
        }
        enum "appqoe-sipc-status-probe" {
          value 2;
          description
            "SIPC is probing the status";
        }
      }
      description "SIPC FIFO pause status";
    }

    typedef wcapi-peer-status {
      type enumeration {
        enum "wcapi-status-unknown" {
          value 0;
          description
            "WCAPI connection to peer is unknown";
        }
        enum "wcapi-status-up" {
          value 1;
          description
            "WCAPI connection to peer is up";
        }
        enum "wcapi-status-down" {
          value 2;
          description
            "WCAPI connection to peer is down";
        }
      }
      description "WCAPI peer status";
    }

    grouping appqoe-sc {
      description
        "Service controller detail";
      leaf sc-lan-ip {
        type inet:ip-address;
        description
          "Local Area Network Internet Protocol
         (LAN IP) address of service controller";
      }

      leaf system-ip {
        type inet:ip-address;
        description
          "System Internet Protocol (IP) address of
         service controller";
      }

      leaf site-id {
        type uint32;
        description
          "Site Identifier (ID) of service controller";
      }

      leaf sn-lan-ip {
        type inet:ip-address;
        description
          "Local Area Network Internet Protocol
         (LAN IP) address of service node";
      }
    }  // grouping appqoe-sc

    grouping appqoe-nat-stats {
      description "NAT statistics";
      leaf insert-succ {
        type uint64;
        description
          "Insert into the table is successful";
      }

      leaf delete-succ {
        type uint64;
        description
          "Delete from the table is successful";
      }

      leaf dup-entries {
        type uint64;
        description
          "Duplicate NAT entry found";
      }

      leaf alloc-fail {
        type uint64;
        description
          "Memory allocation failed for NAT entry";
      }

      leaf port-alloc-succ {
        type uint64;
        description
          "Allocation for port is successful for NAT translation";
      }

      leaf port-alloc-fail {
        type uint64;
        description
          "Allocation for port failed for NAT translation";
      }

      leaf port-free-succ {
        type uint64;
        description
          "Port free successful for NAT entry";
      }

      leaf port-free-fail {
        type uint64;
        description
          "Port free failed for NAT entry";
      }
    }  // grouping appqoe-nat-stats

    grouping libsppi-queue-stats {
      description
        "For queue 0 or queue 1 in SPPI";
      leaf queue-num {
        type uint32;
        description
          "Number of queues is in use in SPPI";
      }

      leaf in-use {
        type uint64;
        description
          "Queue is in use in SPPI";
      }

      leaf not-init {
        type uint64;
        description
          "Queue not initialized in use in SPPI";
      }

      leaf nomem {
        type uint64;
        description
          "No memory available in SPPI";
      }

      leaf no-dev {
        type uint64;
        description
          "No device available in SPPI";
      }

      leaf invalid-mode {
        type uint64;
        description "Invalid mode in SPPI";
      }

      leaf invalid-ring {
        type uint64;
        description "Invalid ring in SPPI";
      }

      leaf invalid-ring-type {
        type uint64;
        description
          "Invalid ring type in SPPI";
      }

      leaf invalid-size {
        type uint64;
        description "Invalid size in SPPI";
      }

      leaf mmap-error {
        type uint64;
        description
          "Memory map error in SPPI";
      }

      leaf poll-error {
        type uint64;
        description "Polling error in SPPI";
      }

      leaf sock-error {
        type uint64;
        description "Socket error in SPPI";
      }

      leaf no-pkt-buf {
        type uint64;
        description
          "No packet buffer in SPPI";
      }

      leaf no-iov-buf {
        type uint64;
        description
          "No IO vector buffer in SPPI";
      }

      leaf truncated {
        type uint64;
        description
          "Truncated packets in SPPI";
      }

      leaf pkt-losing {
        type uint64;
        description "Lost packets in SPPI";
      }

      leaf pkt-send-failed {
        type uint64;
        description
          "Packet send failed in SPPI";
      }

      leaf pkt-read-failed {
        type uint64;
        description
          "Packet read failed in SPPI";
      }

      leaf pkt-available {
        type uint64;
        description
          "Packet available in SPPI";
      }

      leaf pkt {
        type uint64;
        description
          "Number of packets in SPPI";
      }

      leaf tpkt-version-error {
        type uint64;
        description
          "Packet memory map version error in SPPI";
      }
    }  // grouping libsppi-queue-stats

    grouping libsppi-pipe-stats {
      description
        "For control or data channels in SPPI";
      leaf p-invalid-queue-id {
        type uint64;
        description
          "Invalid queue id for pipe in SPPI";
      }

      leaf p-in-use {
        type uint64;
        description "Pipe is in use in SPPI";
      }

      leaf p-sock-error {
        type uint64;
        description
          "Socket error with respect to pipe in SPPI";
      }

      leaf p-ifindex-error {
        type uint64;
        description
          "Index failed for pipe in SPPI";
      }

      leaf p-invalid-mtu {
        type uint64;
        description
          "Invalid MTU failed for pipe in SPPI";
      }

      leaf p-disconnect {
        type uint64;
        description
          "Connection disconnected for pipe in SPPI";
      }
    }  // grouping libsppi-pipe-stats

    grouping libsppi-channel-stats {
      description
        "For control or data channels in SPPI";
      leaf channel-num {
        type uint32;
        description
          "Number of channels in SPPI";
      }

      container pipe {
        description "For pipe in SPPI";
        uses appqoe-xe-oper:libsppi-pipe-stats;
      }  // container pipe

      list queue {
        description "For queue in SPPI";
        uses appqoe-xe-oper:libsppi-queue-stats;
      }  // list queue
    }  // grouping libsppi-channel-stats

    grouping libsppi-stats {
      description
        "APPQOE statistics for SPPI ";
      list channel {
        description
          "For control or data packets in SPPI";
        uses appqoe-xe-oper:libsppi-channel-stats;
      }  // list channel
    }  // grouping libsppi-stats

    grouping appqoe-rm-global-resource {
      description
        "APPQOE RM global resources";
      leaf max-serv-mem {
        type uint64;
        units "kilobytes";
        description
          "Maximum service memory available for use";
      }

      leaf used-serv-mem {
        type uint64;
        units "kilobytes";
        description
          "Currently used service memory";
      }

      leaf avail-sys-mem {
        type uint64;
        units "kilobytes";
        description
          "Currently available system memory";
      }

      leaf per-used-serv-mem {
        type uint8;
        units "percentage";
        description
          "Used service memory in percentage";
      }

      leaf rm-svc-mem-flag {
        type appqoe-rm-status;
        description
          "Service memory status flag";
      }

      leaf rm-tcp-sess-flag {
        type appqoe-rm-status;
        description
          "TCP session status flag";
      }

      leaf rm-global-health-flag {
        type appqoe-rm-status;
        description
          "Overall health status flag";
      }
    }  // grouping appqoe-rm-global-resource

    grouping appqoe-rm-serv {
      description
        "APPQOE RM client statistics";
      leaf max-sess {
        type uint32;
        description
          "Maximum sessions allowed for the client";
      }

      leaf used-sess {
        type uint32;
        description
          "Number of used sessions by the client";
      }

      leaf mem-per-sess {
        type uint32;
        units "kilobytes";
        description
          "Memory required per session for the client";
      }
    }  // grouping appqoe-rm-serv

    grouping appqoe-rm-resources {
      description
        "APPQOE RM resources statistics";
      container glob {
        description
          "Service wide resources statistics";
        uses appqoe-xe-oper:appqoe-rm-global-resource;
      }  // container glob

      container dre {
        description
          "DRE resources statistics";
        uses appqoe-xe-oper:appqoe-rm-serv;
      }  // container dre

      container ssl {
        description
          "SSL resources statistics";
        uses appqoe-xe-oper:appqoe-rm-serv;
      }  // container ssl

      container tcp {
        description
          "TCP resources statistics";
        uses appqoe-xe-oper:appqoe-rm-serv;
      }  // container tcp

      container http {
        description
          "HTTP resources statistics";
        uses appqoe-xe-oper:appqoe-rm-serv;
      }  // container http
    }  // grouping appqoe-rm-resources

    grouping hput-channel-stat {
      description "Statistics for HPUT";
      leaf hs-min-sch-delay {
        type uint64;
        units "microseconds";
        description
          "Min scheduling delay to schedule thread";
      }

      leaf hs-max-sch-delay {
        type uint64;
        units "microseconds";
        description
          "Max scheduling delay to schedule thread";
      }

      leaf hs-timer-add-req {
        type uint64;
        description
          "Request to add HPUT timer";
      }

      leaf hs-timer-added {
        type uint64;
        description
          "Timer added successfully";
      }

      leaf hs-timer-add-expired {
        type uint64;
        description
          "Timer expired before adding timer request";
      }

      leaf hs-timer-del-req {
        type uint64;
        description
          "Request to delete Timer";
      }

      leaf hs-timer-deleted {
        type uint64;
        description
          "Timer deleted successfully";
      }

      leaf hs-timer-del-failed {
        type uint64;
        description "Timer delete failed";
      }

      leaf hs-timer-alloc {
        type uint64;
        description "Timer node allocation";
      }

      leaf hs-timer-dealloc {
        type uint64;
        description
          "Timer node de-allocation";
      }

      leaf hs-time-node-alloc {
        type uint64;
        description "Time node allocation";
      }

      leaf hs-time-node-dealloc {
        type uint64;
        description
          "Time node de-allocation";
      }

      leaf hs-time-node-added {
        type uint64;
        description
          "Time node added successfully in tree";
      }

      leaf hs-time-node-exist {
        type uint64;
        description
          "Time node already exists in tree";
      }

      leaf hs-time-node-deleted {
        type uint64;
        description
          "Time node deleted from tree";
      }

      leaf hs-time-node-expired {
        type uint64;
        description "Time node expired";
      }

      leaf hs-timer-cb {
        type uint64;
        description
          "No timer callback called";
      }

      leaf hs-ktimer-cb {
        type uint64;
        description "Kernel timer callback";
      }

      leaf hs-ktimer-start {
        type uint64;
        description "Kernel timer start";
      }

      leaf hs-ktimer-stop {
        type uint64;
        description "Kernel timer stop";
      }

      leaf hs-expired-list-alloc {
        type uint64;
        description
          "Expired list allocation";
      }

      leaf hs-expired-list-dealloc {
        type uint64;
        description
          "Expired list de-allocation";
      }

      leaf hs-curr-node-null {
        type uint64;
        description
          "Current node which processing kernel callback";
      }

      leaf hs-curr-node-ts-not-valid {
        type uint64;
        description
          "Current node TS is not expired";
      }

      leaf hs-exp-list-process {
        type uint64;
        description "Expired list processed";
      }

      leaf hs-expired-send-sig {
        type uint64;
        description
          "Delete expired signal send";
      }

      leaf hs-pending-list-process {
        type uint64;
        description
          "Pending list processing";
      }

      leaf hs-sch-delay10us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 10 microsecond";
      }

      leaf hs-sch-delay20us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 20 microsecond";
      }

      leaf hs-sch-delay30us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 30 microsecond";
      }

      leaf hs-sch-delay40us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 40 microsecond";
      }

      leaf hs-sch-delay50us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 50 microsecond";
      }

      leaf hs-sch-delay100us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 100 microsecond";
      }

      leaf hs-sch-delay200us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 200 microsecond";
      }

      leaf hs-sch-delay300us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 300 microsecond";
      }

      leaf hs-sch-delay400us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 400 microsecond";
      }

      leaf hs-sch-delay500us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 500 microsecond";
      }

      leaf hs-sch-delay600us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 600 microsecond";
      }

      leaf hs-sch-delay700us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 700 microsecond";
      }

      leaf hs-sch-delay800us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 800 microsecond";
      }

      leaf hs-sch-delay900us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 900 microsecond";
      }

      leaf hs-sch-delay1000us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 1 ms";
      }

      leaf hs-sch-delay10000us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 10 ms";
      }

      leaf hs-sch-delay100000us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 100 ms";
      }

      leaf hs-sch-delay1000000us {
        type uint64;
        units "microseconds";
        description
          "Scheduling delay less than 1000 ms";
      }
    }  // grouping hput-channel-stat

    grouping hput-timer-stat {
      description
        "HPUT timer statistics for system and high precision timers";
      leaf uhs-callout {
        type uint64;
        description
          "Call-out function is called";
      }

      leaf uhs-callout-del {
        type uint64;
        description
          "Call-out marked for cancelled";
      }

      leaf uhs-callout-not-pending {
        type uint64;
        description "Call-out not pending";
      }

      leaf uhs-callout-cancel {
        type uint64;
        description
          "Call-out cancel when trying to execute callback";
      }

      leaf uhs-callout-lock {
        type uint64;
        description "Call-out class lock";
      }

      leaf uhs-callout-unlock {
        type uint64;
        description "Call-out class unlock";
      }

      leaf uhs-callout-drain {
        type uint64;
        description
          "Call-out drain function called";
      }

      leaf uhs-callout-done {
        type uint64;
        description "Call-out marked done";
      }

      leaf uhs-callout-call {
        type uint64;
        description
          "Calling callback from call-out";
      }

      leaf uhs-add {
        type uint64;
        description "Call-out add";
      }

      leaf uhs-add-fail {
        type uint64;
        description "Call-out add failed";
      }

      leaf uhs-rst-sbt-req {
        type uint64;
        description
          "Call-out reset on request";
      }

      leaf uhs-rst-sbt-drain {
        type uint64;
        description
          "Call-out drain function is called so do not reschedule call-out";
      }

      leaf uhs-rst-sbt-cancel {
        type uint64;
        description
          "Call-out not found but still we can cancel it";
      }

      leaf uhs-rst-sbt-del {
        type uint64;
        description "Call-out deleted";
      }

      leaf uhs-rst-sbt-add {
        type uint64;
        description "Call-out add request";
      }

      leaf uhs-stop {
        type uint64;
        description "Call-out stop request";
      }

      leaf uhs-stop-nodrain {
        type uint64;
        description
          "Call-out stop request with no drain";
      }

      leaf uhs-stop-drain {
        type uint64;
        description
          "Call-out stop request with drain";
      }

      leaf uhs-stop-cancel {
        type uint64;
        description
          "Call-out stop request to cancel the call-out";
      }

      leaf uhs-stop-no-pending {
        type uint64;
        description
          "Call-out pending is not set while stop";
      }

      leaf uhs-stop-del-cancel {
        type uint64;
        description
          "Call-out stop to cancel the call-out";
      }

      leaf uhs-stop-del {
        type uint64;
        description
          "Call-out stop to delete the call-out";
      }

      leaf uhs-raw-add {
        type uint64;
        description "Call-out raw add";
      }

      leaf uhs-raw-add-failed {
        type uint64;
        description
          "Call-out raw add failed";
      }

      leaf uhs-raw-cb {
        type uint64;
        description "Call-out raw callback";
      }
    }  // grouping hput-timer-stat

    grouping hput-stats-cpu {
      description "HPUT statistics per CPU ";
      leaf uihs-nr-hpts-cpu {
        type uint8;
        description
          "Number of high precision timers per CPU";
      }

      container channel {
        description "HPUT timer statistics";
        uses appqoe-xe-oper:hput-channel-stat;
      }  // container channel

      container timer {
        description
          "HPUT timer statistics for system";
        uses appqoe-xe-oper:hput-timer-stat;
      }  // container timer
    }  // grouping hput-stats-cpu

    grouping hput-stats {
      description "APPQOE HPUT statistics ";
      list stat {
        description "HPUT statistics";
        uses appqoe-xe-oper:hput-stats-cpu;
      }  // list stat
    }  // grouping hput-stats

    grouping rm-client-stat {
      description
        "Resource manager client statistics";
      leaf client-num {
        type uint8;
        description
          "Number of clients for RM";
      }

      leaf tcp-sess-alloc {
        type uint32;
        description
          "TCP session allocation for RM client";
      }

      leaf tcp-sess-free {
        type uint32;
        description
          "TCP session free for RM client";
      }

      leaf ssl-sess-alloc {
        type uint32;
        description
          "SSL session allocation for RM client";
      }

      leaf ssl-sess-free {
        type uint32;
        description
          "SSL session free for RM client";
      }

      leaf dre-sess-alloc {
        type uint32;
        description
          "Container session allocation for RM client";
      }

      leaf dre-sess-free {
        type uint32;
        description
          "Container session free for RM client";
      }

      leaf http-sess-alloc {
        type uint32;
        description
          "HTTP session allocation for RM client";
      }

      leaf http-sess-free {
        type uint32;
        description
          "HTTP session free for RM client";
      }
    }  // grouping rm-client-stat

    grouping rm-stats {
      description
        "Resource manager statistics";
      leaf session-health-yellow-cnt {
        type uint64;
        description
          "Session health yellow status for RM";
      }

      leaf session-health-green-cnt {
        type uint64;
        description
          "Session health green status for RM";
      }

      leaf svc-mem-health-yellow-cnt {
        type uint64;
        description
          "Memory health yellow status for RM";
      }

      leaf svc-mem-health-green-cnt {
        type uint64;
        description
          "Memory health green status for RM";
      }

      leaf overall-health-yellow-cnt {
        type uint64;
        description
          "Overall health yellow status for RM";
      }

      leaf overall-health-green-cnt {
        type uint64;
        description
          "Overall health green status for RM";
      }

      leaf dre-reserve-failure-cnt {
        type uint64;
        description
          "DRE reserve failures due to health status for RM";
      }

      list stat {
        description "Client stats for RM";
        uses appqoe-xe-oper:rm-client-stat;
      }  // list stat
    }  // grouping rm-stats

    grouping bstates {
      description "BBR States";
      leaf state-type {
        type bbr-state;
        description "BBR state type";
      }

      leaf state-value {
        type uint64;
        description "BBR state value";
      }
    }  // grouping bstates

    grouping bstate-tran {
      description "BBR state transition";
      leaf st-type {
        type state-tran;
        description
          "BBR state transition type";
      }

      leaf st-value {
        type uint64;
        description
          "BBR State transition value";
      }
    }  // grouping bstate-tran

    grouping btimer-source {
      description "HPTS timer started";
      leaf ts-type {
        type timer-source;
        description
          "List of HPTS timer started";
      }

      leaf ts-value {
        type uint64;
        description
          "HPTS timer started value";
      }
    }  // grouping btimer-source

    grouping bslot {
      description "Pacing Delay";
      leaf slot-type {
        type bbr-slot;
        description "Pacing delay type";
      }

      leaf slot-value {
        type uint64;
        description "Pacing delay value";
      }
    }  // grouping bslot

    grouping brem-timer {
      description "HPTS timer stopped";
      leaf rt-type {
        type rem-timer;
        description
          "List of HPTS timer stopped";
      }

      leaf rt-value {
        type uint64;
        description
          "HPTS Timer stopped value";
      }
    }  // grouping brem-timer

    grouping bbw {
      description "Bandwidth distribution";
      leaf bw-type {
        type bbr-bw;
        description "Bandwidth type";
      }

      leaf bw-value {
        type uint64;
        description "Bandwidth value";
      }
    }  // grouping bbw

    grouping brtt {
      description "RTT (in ms)";
      leaf rtt-type {
        type bbr-rtt;
        description "RTT type";
      }

      leaf rtt-value {
        type uint64;
        description "RTT value";
      }
    }  // grouping brtt

    grouping appqoe-libuinet-stats {
      description
        "Application Quality of Experience (APPQOE) TCP/IP stack statistics";
      leaf sppi-pkt-avail {
        type uint64;
        description
          "Packets received by Service Plane Packet Interface (SPPI)";
      }

      leaf sppi-pkt-avail-error {
        type uint64;
        description
          "Packets dropped by SPPI";
      }

      leaf sppi-rx {
        type uint64;
        description
          "Packets successfully processed by SPPI";
      }

      leaf sppi-rx-fail {
        type uint64;
        description
          "SPPI failed to process packets";
      }

      leaf sppi-tx {
        type uint64;
        description
          "Packets successfully transmitted by SPPI";
      }

      leaf sppi-tx-fail {
        type uint64;
        description
          "SPPI failed to transmit packets";
      }

      leaf sppi-tx-full-wait {
        type uint64;
        description
          "Outgoing queue is full while transmitting the packets";
      }

      leaf sppi-pd-alloc-success {
        type uint64;
        description
          "Memory buffer allocation is successful in SPPI";
      }

      leaf sppi-pd-alloc-fail {
        type uint64;
        description
          "Memory buffer allocation is failed in SPPI";
      }

      leaf sppi-pb-curr-cnt {
        type uint64;
        description
          "Free blocks available with SPPI";
      }

      leaf sppi-pipe-disconnect {
        type uint64;
        description
          "SPPI is disconnected from Memory Interface Channel";
      }

      leaf vpath-in {
        type uint64;
        description
          "Packets received by APPQOE TCP/IP stack";
      }

      leaf vpath-ctrl-pkt {
        type uint64;
        description
          "Control packets received by APPQOE TCP/IP stack";
      }

      leaf vpath-data-pkt {
        type uint64;
        description
          "Date packets received by APPQOE TCP/IP stack";
      }

      leaf vpath-drop {
        type uint64;
        description
          "Packets dropped by APPQOE TCP/IP stack";
      }

      leaf vpath-non-vpath {
        type uint64;
        description
          "Non virtual path packets received by APPQOE TCP/IP stack";
      }

      leaf vpath-decap {
        type uint64;
        description
          "Received packets successfully unwrap by APPQOE TCP/IP stack";
      }

      leaf vpath-encap {
        type uint64;
        description
          "Received packets successfully encapsulate by APPQOE TCP/IP stack";
      }

      leaf vpath-out {
        type uint64;
        description
          "Packets transmitted by APPQOE TCP/IP stack";
      }

      leaf vpath-syn-pkt {
        type uint64;
        description
          "TCP SYN segments received by APPQOE TCP/IP stack";
      }

      leaf vpath-ip-input-pkts {
        type uint64;
        description
          "TCP packets intercepted by APPQOE TCP/IP stack ";
      }

      leaf vpath-ip-input-bytes {
        type uint64;
        description
          "Total bytes received by APPQOE TCP/IP stack";
      }

      leaf vpath-ip-output-pkts {
        type uint64;
        description
          "TCP packets transmitted by APPQOE TCP/IP stack";
      }

      leaf vpath-ip-output-bytes {
        type uint64;
        description
          "TCP bytes transmitted by APPQOE TCP/IP stack";
      }

      leaf vpath-flow-info-alloc {
        type uint64;
        description
          "TCP connections flow entries created";
      }

      leaf vpath-flow-info-alloc-fail {
        type uint64;
        description
          "TCP connections flow entries creations failed";
      }

      leaf vpath-flow-info-free {
        type uint64;
        description
          "TCP connections flow freed";
      }

      leaf vpath-rx-ver-probe-pkts {
        type uint64;
        description
          "Version probe packets received by APPQOE TCP/IP Stack";
      }

      leaf vpath-rx-control-pkts {
        type uint64;
        description
          "Control packets received by APPQOE TCP/IP Stack";
      }

      leaf vp-rx-ctl-msg-hprobe-pkts {
        type uint64;
        description
          "Control health probe packets received by APPQOE TCP/IP stack";
      }

      leaf vp-nat-lkup-failed-non-syn {
        type uint64;
        description
          "Nat lookup is failed for incoming TCP non SYN packet in
         APPQOE TCP/IP stack";
      }

      leaf vp-nat-lkup-success-syn {
        type uint64;
        description
          "Nat lookup is successfully for incoming SYN packets in
         APPQOE TCP/IP stack";
      }

      leaf vpath-icmp-in {
        type uint64;
        description
          "ICMP packets received by APPQOE TCP/IP stack";
      }

      leaf vpath-icmp-success {
        type uint64;
        description
          "ICMP successfully processed by APPQOE TCP/IP stack";
      }

      leaf vpath-icmp-failure {
        type uint64;
        description
          "Failed to process received ICMP packets by APPQOE TCP/IP stack";
      }

      leaf vpath-min-mbuf-threshold {
        type uint64;
        description
          "Packets dropped due to minimum threshold";
      }

      leaf vpath-syn-pps-drop {
        type uint64;
        description
          "SYN dropped due to maximum packet per second reached";
      }

      leaf vpath-conn-del-pkts {
        type uint64;
        description
          "TCP connection flow delete notification packets sent";
      }

      leaf vp-conndelpkts-alloc-fail {
        type uint64;
        description
          "Flow delete notification packets allocation failed";
      }

      leaf vpath-conn-del-pkts-fail {
        type uint64;
        description
          "Failed to send flow delete notification packets";
      }

      leaf vpath-new-con-failed {
        type uint64;
        description
          "Failed to create new TCP connection";
      }

      leaf vp-flowinfosn-ip-not-set {
        type uint64;
        description
          "TCP connection flow does not get Service Node (SN) IP Address";
      }

      leaf vpath-sn-ip-map-added {
        type uint64;
        description "Added SN IP Map";
      }

      leaf vpath-sn-ip-map-updated {
        type uint64;
        description "Updated SN IP Map";
      }

      leaf vp-sn-ip-map-overwritten {
        type uint64;
        description "Overwritten SN IP Map";
      }

      leaf vpath-sn-ip-map-not-added {
        type uint64;
        description
          "Failed to add SN IP Map";
      }

      leaf vpath-sn-ip-map-not-found {
        type uint64;
        description
          "Failed to find SN IP Map";
      }

      leaf vpath-netisr-ip-drop {
        type uint64;
        description
          "IP Packets dropped by APPQOE TCP/IP stack";
      }

      leaf vpath-ip-frag-pkt {
        type uint64;
        description
          "Received IP fragmented packets by APPQOE TCP/IP stack";
      }

      leaf vpath-ad-opt-not-added {
        type uint64;
        description
          "Auto discovery options not added due to insufficient size";
      }

      leaf bbr-connection-init {
        type uint64;
        description
          "Connections initialized by APPQOE TCP/IP
         Bottleneck Bandwidth and Round-trip propagation time (BBR) Stack";
      }

      leaf bbr-connection-finish {
        type uint64;
        description
          "Connections Finished through APPQOE TCP/IP BBR Stack";
      }

      leaf bbr-active-conn {
        type uint64;
        description
          "Total active connections";
      }

      leaf bbr-to-alloc {
        type uint64;
        description
          "Send map allocation success";
      }

      leaf bbr-to-alloc-failed {
        type uint64;
        description
          "Send map allocated from free list";
      }

      leaf bbr-to-alloc-emerg {
        type uint64;
        description
          "Send map allocation failed";
      }

      list state {
        description
          "APPQOE TCP/IP BBR stack states";
        uses appqoe-xe-oper:bstates;
      }  // list state

      list trans {
        description
          "APPQOE TCP/IP BBR stack state transition";
        uses appqoe-xe-oper:bstate-tran;
      }  // list trans

      list source {
        description
          "High Precision Timer System (HPTS) timer started";
        uses appqoe-xe-oper:btimer-source;
      }  // list source

      list slot {
        description "Pacing Delay (in us)";
        uses appqoe-xe-oper:bslot;
      }  // list slot

      list timer {
        description "HPTS timer stopped";
        uses appqoe-xe-oper:brem-timer;
      }  // list timer

      list conn-bw {
        description "Bandwidth distribution";
        uses appqoe-xe-oper:bbw;
      }  // list conn-bw

      list pkt-rtt {
        description
          "Round Trip Time (RTT) (in millisecond)";
        uses appqoe-xe-oper:brtt;
      }  // list pkt-rtt

      leaf bbr-output-bytes {
        type uint64;
        description
          "Bytes sent by APPQOE TCP/IP BBR stack";
      }

      leaf bbr-segment-lost {
        type uint64;
        description
          "TCP segments lost sent by APPQOE TCP/IP BBR stack";
      }

      leaf bbr-ip-output {
        type uint64;
        description
          "TCP segment sent through APPQOE TCP/IP BBR stack";
      }

      leaf bbr-early {
        type uint64;
        description
          "Timer has expired early";
      }

      leaf bbr-xmit {
        type uint64;
        description
          "Retransmitted segments sent by APPQOE TCP/IP BBR stack";
      }

      leaf bbr-output-seg {
        type uint64;
        description
          "TCP segment sent through HPTS timer";
      }

      leaf bbr-delay {
        type uint64;
        description "Delay in timer expiry";
      }

      leaf hpts-need-wakeup {
        type uint64;
        description
          "Timer woke up immediately";
      }

      leaf hpts-schedule-callout {
        type uint64;
        description "Call out scheduled";
      }

      leaf hpts-lastt-gt-currt {
        type uint64;
        description
          "Last tick is greater than current tick";
      }

      leaf hpts-maxtick-overflow {
        type uint64;
        description "Max ticks overflow";
      }

      leaf hpts-inp-same-slot {
        type uint64;
        description
          "Internet Protocol Block added back to same slot";
      }

      leaf hpts-dis-to-travel-oflow {
        type uint64;
        description
          "Distance to travel Overflow";
      }

      leaf hpts-avail-on-wheel-oflow {
        type uint64;
        description
          "Available on wheel overflow";
      }

      leaf hpts-availonwheel-lt-pacer {
        type uint64;
        description
          "Available On wheel less than pacer";
      }

      leaf hpts-hopelessly-behind {
        type uint64;
        description
          "HPTS is hopelessly behind";
      }

      leaf hpts-exceed-wheel-time {
        type uint64;
        description
          "HPTS wheel time exceeded";
      }

      leaf hpts-loops {
        type uint64;
        description "HPTS stuck in loop";
      }

      leaf hpts-back-tosleep {
        type uint64;
        description "HPTS is back on sleep";
      }

      leaf hpts-wheel-wrap {
        type uint64;
        description "HPTS wheel wrapped";
      }

      leaf bbr-peer-unsupport-sack {
        type uint64;
        description
          "TCP Connection without Selective Acknowledgement (SACK) support";
      }

      leaf bbr-snd-buffer-full {
        type uint64;
        description
          "Maximum send buffer reached";
      }

      leaf bbr-max-snd-cwnd {
        type uint64;
        description
          "Maximum send congestion window";
      }

      leaf bbr-snd-wnd {
        type uint64;
        description
          "Current TCP send window";
      }

      leaf bbr-fin-wait-2-force {
        type uint64;
        description
          "Forced close from FINISH WAIT 2";
      }
    }  // grouping appqoe-libuinet-stats

    grouping ebp-own {
      description
        "Elastic Buffer Pool (EBP) owner Info";
      leaf val {
        type uint64;
        description "Value of EBP owner";
      }

      leaf owner-name {
        type string;
        description "Name of EBP owner";
      }
    }  // grouping ebp-own

    grouping infra-ebp-blk-info {
      description "EBP Info";
      leaf walk-key {
        type uint32;
        description
          "Unique key to walk the list";
      }

      leaf blk-shm-size {
        type uint32;
        units "bytes";
        description "Shared memory size";
      }

      leaf total-num-free {
        type uint32;
        description "Number of free blocks";
      }

      leaf buf-size {
        type uint32;
        units "bytes";
        description "Buffer size";
      }

      leaf num-bufs {
        type uint32;
        description
          "Total number of buffers";
      }

      leaf blk-oid {
        type uint32;
        description "Block owner ID";
      }

      leaf eid {
        type uint32;
        description "EBP Block ID";
      }

      list blk-num-returned {
        description
          "Returned buffers to block";
        uses appqoe-xe-oper:ebp-own;
      }  // list blk-num-returned

      list num-free-per-owner {
        description "Free buffers";
        uses appqoe-xe-oper:ebp-own;
      }  // list num-free-per-owner

      list blk-num-used {
        description "Used buffers";
        uses appqoe-xe-oper:ebp-own;
      }  // list blk-num-used
    }  // grouping infra-ebp-blk-info

    grouping block-stats {
      description "Block statistics";
      leaf index {
        type uint8;
        description
          "Index of the block statistics";
      }

      leaf mask {
        type uint32;
        description
          "Bitmask of the block statistics";
      }

      leaf exp {
        type uint32;
        description
          "Mask to the power of two, for the block statistics";
      }

      leaf gc-min-threshold-bufs {
        type uint32;
        description
          "Garbage Collector (GC) minimum threshold buffers";
      }

      leaf aa-num-bufs {
        type uint32;
        description
          "Auto Allocated (AA) number of buffers";
      }

      leaf num-auto-alloc-blks {
        type uint32;
        description "Number of AA blocks";
      }
    }  // grouping block-stats

    grouping cool-down {
      description "Cool down statistics";
      leaf val {
        type uint32;
        description "Cool down value";
      }

      leaf exp {
        type uint32;
        description "Cool down mask";
      }
    }  // grouping cool-down

    grouping infra-ebp-gc-stats {
      description "GC statistics";
      leaf gc-num-del-blks {
        type uint32;
        description
          "Total GC deleted blocks";
      }

      leaf gc-num-closed-blks {
        type uint32;
        description "Total GC closed blocks";
      }

      leaf gc-get-buf-cl-blks {
        type uint32;
        description
          "Total blocks reopened due to dirty bit set";
      }

      leaf gc-count {
        type uint32;
        description "Total GC call count";
      }

      leaf last-gc-time {
        type uint32;
        units "seconds";
        description "Time since GC called";
      }

      leaf gc-cdown-set-count {
        type uint32;
        description
          "Total GC cool down timer set count";
      }

      list gc-cdown-bucket {
        description "Cool down buckets";
        uses appqoe-xe-oper:cool-down;
      }  // list gc-cdown-bucket

      container gc-cdown-bucket-last {
        description "Last cool down buckets";
        uses appqoe-xe-oper:cool-down;
      }  // container gc-cdown-bucket-last

      leaf gc-auto-alloc-status {
        type uint32;
        description "AA status";
      }

      leaf gc-aa-disabled {
        type uint32;
        description "AA is disabled";
      }

      leaf gc-min-buf-th-reached {
        type uint32;
        description
          "GC min buffer threshold reached";
      }

      leaf gc-blk-in-use {
        type uint32;
        description "EBP block is in use";
      }
    }  // grouping infra-ebp-gc-stats

    grouping infra-ebp-aa-stats {
      description "AA statistics";
      leaf aa-auto-alloc-status {
        type uint32;
        description "AA status";
      }

      leaf tot-num-auto-alloc-blks {
        type uint32;
        description "Total AA blocks";
      }

      leaf time-since-last-auto-alloc {
        type uint32;
        units "seconds";
        description
          "Seconds since last AA block";
      }
    }  // grouping infra-ebp-aa-stats

    grouping infra-ebp-alloc-stats {
      description "Allocation statistics";
      leaf exp-val {
        type uint32;
        units "bytes";
        description "Size of block";
      }

      leaf per-size-active-blk-count {
        type uint32;
        description
          "Per size active block count";
      }

      leaf alloc-fail-per-block-size {
        type uint32;
        description
          "Total allocation failure per block size";
      }
    }  // grouping infra-ebp-alloc-stats

    grouping infra-ebp-error-stats {
      description "EBP Errors";
      leaf print-flag {
        type uint8;
        description
          "Check flag to print errors";
      }

      leaf freelist-shm-runout {
        type uint32;
        description
          "Free list ran out of shared memory";
      }

      leaf invalid-auto-size {
        type uint32;
        description "AA invalid size";
      }

      leaf invalid-auto-param {
        type uint32;
        description "AA invalid parameters";
      }

      leaf invalid-auto-sblk-null {
        type uint32;
        description
          "AA received null super block";
      }

      leaf invalid-threshold-buf-size {
        type uint32;
        description
          "Invalid threshold buffer size";
      }

      leaf inv-threshold-sblk-null {
        type uint32;
        description
          "Threshold received null super block";
      }

      leaf invalid-buffer-offset {
        type uint32;
        description
          "Shared IPC create received invalid buffer offset";
      }

      leaf invalid-buffer-size {
        type uint32;
        description
          "Shared IPC create received invalid buffer size";
      }

      leaf null-buffer-being-return {
        type uint32;
        description
          "Empty buffer being returned";
      }

      leaf init-not-done {
        type uint32;
        description "Init not done";
      }

      leaf shm-creation-failed {
        type uint32;
        description
          "Shared memory creation failed";
      }

      leaf ebp-invalid-param {
        type uint32;
        description "Parameter check failed";
      }

      leaf create-seq-not-done {
        type uint32;
        description
          "Create sequence not done";
      }

      leaf max-memory-limit-reached {
        type uint32;
        description
          "Shared memory memory exhausted";
      }

      leaf sblk-full {
        type uint32;
        description "Super block full";
      }

      leaf malloc-failed {
        type uint32;
        description "Allocation failed";
      }

      leaf ebp-cid-mismatch {
        type uint32;
        description "Client ID mismatch";
      }

      leaf ebp-already-open {
        type uint32;
        description "EBP already opened";
      }

      leaf shm-open-failed {
        type uint32;
        description
          "Shared memory open failed";
      }

      leaf ebp-shm-unmap-fail {
        type uint32;
        description
          "Shared memory unmap failed";
      }

      leaf shm-map-failed {
        type uint32;
        description
          "Shared memory map failed";
      }

      leaf buf-hdr-san-chk-fail {
        type uint32;
        description
          "Header sanity check failed";
      }

      leaf invalid-buf-size {
        type uint32;
        description "Invalid buffer size";
      }

      leaf double-free {
        type uint32;
        description "Double free";
      }

      leaf buf-free-failed {
        type uint32;
        description "Buffer free failed";
      }

      leaf init-state-check-failed {
        type uint32;
        description
          "Init state check failed";
      }

      leaf del-recv-null-ctx {
        type uint32;
        description
          "Empty context during delete";
      }

      leaf auto-no-free-blk {
        type uint32;
        description "No free block after AA";
      }

      leaf ebp-no-free-blk {
        type uint32;
        description "No free blocks";
      }

      leaf shm-nondump-failed {
        type uint32;
        description
          "Shared memory EBP non dumpable failed";
      }
    }  // grouping infra-ebp-error-stats

    grouping appqoe-ebp-stats {
      description "EBP statistics";
      leaf ebp-service-id {
        type tcp-proxy-ebp-service-id;
        description "EBP service identifier";
      }

      leaf num-open-blks {
        type uint32;
        description "Number of open blocks";
      }

      leaf num-active-blks {
        type uint32;
        description
          "Number of active blocks";
      }

      leaf shm-size {
        type uint64;
        units "bytes";
        description "Shared memory size";
      }

      list infra-ebp-blk-info {
        key "walk-key";
        description "EBP block information";
        uses appqoe-xe-oper:infra-ebp-blk-info;
      }  // list infra-ebp-blk-info

      container gc-stats {
        description "GC statistics";
        uses appqoe-xe-oper:infra-ebp-gc-stats;
      }  // container gc-stats

      container aa-stats {
        description "AA statistics";
        uses appqoe-xe-oper:infra-ebp-aa-stats;
      }  // container aa-stats

      list alloc-stat {
        description "Allocation statistics";
        uses appqoe-xe-oper:infra-ebp-alloc-stats;
      }  // list alloc-stat

      container ebp-err {
        description "EBP errors";
        uses appqoe-xe-oper:infra-ebp-error-stats;
      }  // container ebp-err

      list aa-gc-blk-stat {
        description "EBP block statistics";
        uses appqoe-xe-oper:block-stats;
      }  // list aa-gc-blk-stat
    }  // grouping appqoe-ebp-stats

    grouping sipc-efifo-stats {
      description "SIPC error FIFO stats";
      leaf enq-fail-mf-full {
        type uint32;
        description
          "Enqueue failed due to memory full";
      }

      leaf enq-fail-fifo-alloc {
        type uint32;
        description
          "Enqueue failed due to FIFO allocation failed";
      }

      leaf enq-fail-fifo-init {
        type uint32;
        description
          "Enqueue FIFO initialization failed";
      }

      leaf enq-fail-enq-to-mf {
        type uint32;
        description
          "Enqueue failed memory full";
      }

      leaf enq-fail-unexpected {
        type uint32;
        description
          "Enqueue failed unexpectedly";
      }

      leaf enq-fail-fifo-switch-msg {
        type uint32;
        description
          "Enqueue FIFO switch message failed";
      }

      leaf deq-fail-no-data {
        type uint64;
        description
          "Dequeue failed because of no data";
      }

      leaf deq-fail-no-new-fifo {
        type uint32;
        description
          "Dequeue failed with no new FIFO";
      }

      leaf deq-fail-fifo-alloc {
        type uint32;
        description
          "Dequeue FIFO failed to allocate";
      }
    }  // grouping sipc-efifo-stats

    grouping sipc-fifo-debug-stats {
      description
        "Shared memory inter process communication (SIPC) FIFO debug stats";
      leaf fifo-type {
        type sipc-fifo-type;
        description "Type of SIPC FIFO";
      }

      leaf count {
        type uint32;
        description
          "Number of messages currently in SIPC FIFO";
      }

      leaf enq-count {
        type uint64;
        description
          "Number of messages enqueued successfully in SIPC FIFO";
      }

      leaf deq-count {
        type uint64;
        description
          "Number of messages dequeued successfully from SIPC FIFO";
      }

      leaf length {
        type uint32;
        description "Length of SIPC FIFO";
      }

      leaf ht {
        type uint32;
        description
          "SIPC FIFO high threshold";
      }

      leaf lt {
        type uint32;
        description
          "SIPC FIFO low threshold";
      }

      leaf pause {
        type sipc-pause-status;
        description "SIPC FIFO pause status";
      }

      container estats {
        description
          "SIPC FIFO enqueue statistics";
        uses appqoe-xe-oper:sipc-efifo-stats;
      }  // container estats
    }  // grouping sipc-fifo-debug-stats

    grouping sipc-err-stats {
      description "SIPC error statistics";
      leaf sipc-mem-alloc-failed {
        type uint32;
        description
          "SIPC memory allocation failed count";
      }

      leaf sipc-sem-init-failed {
        type uint32;
        description
          "SIPC semaphore initialization failed count";
      }

      leaf sipc-shmem-open-failed {
        type uint32;
        description
          "SIPC shared memory open failed count";
      }

      leaf sipc-shmem-unmap-failed {
        type uint32;
        description
          "SIPC shared memory unmap failed count";
      }

      leaf sipc-shmem-map-failed {
        type uint32;
        description
          "SIPC shared memory map failed count";
      }

      leaf sipc-thread-init-failed {
        type uint32;
        description
          "SIPC thread creation failed count";
      }
    }  // grouping sipc-err-stats

    grouping appqoe-sipc-stats {
      description "SIPC statistics";
      leaf service-id {
        type sipc-service-id;
        description
          "SIPC shared memory service";
      }

      leaf shm-name {
        type string;
        description
          "SIPC shared memory service name";
      }

      leaf sock-fd {
        type uint32;
        description
          "SIPC socket file descriptor";
      }

      leaf peer-id {
        type uint32;
        description "SIPC peer identifier";
      }

      leaf peer-status {
        type wcapi-peer-status;
        description "SIPC peer status";
      }

      leaf rx-count {
        type uint32;
        description
          "Number of messages in receive queue";
      }

      leaf rx-enq-count {
        type uint64;
        description
          "Number of enqueued messages in receive queue";
      }

      leaf rx-deq-count {
        type uint64;
        description
          "Number of messages dequeued from receive queue";
      }

      leaf tx-count {
        type uint32;
        description
          "Number of messages in transmit queue";
      }

      leaf tx-enq-count {
        type uint64;
        description
          "Number of enqueued messages in transmit queue";
      }

      leaf tx-deq-count {
        type uint64;
        description
          "Number of messages dequeued from transmit queue";
      }

      leaf num-rx-fifos {
        type uint32;
        description
          "Total number of receive FIFO";
      }

      leaf num-tx-fifos {
        type uint32;
        description
          "Total number of transmit FIFO";
      }

      leaf rx-thread-id {
        type uint64;
        description
          "Receiver thread identifier";
      }

      leaf tx-notify-thread-id {
        type uint64;
        description
          "Transmit notify thread identifier";
      }

      leaf shm-size {
        type uint32;
        units "bytes";
        description "Shared memory size";
      }

      leaf rx-thread-enable {
        type boolean;
        description "Receive thread enabled";
      }

      leaf tx-notify-thread-enable {
        type boolean;
        description
          "Transmit thread notify enabled";
      }

      leaf flow-control-enable {
        type boolean;
        description
          "Flow control enable status";
      }

      container tx-debug-stats {
        description
          "Debug statistics of transmit queue";
        uses appqoe-xe-oper:sipc-fifo-debug-stats;
      }  // container tx-debug-stats

      container rx-debug-stats {
        description
          "Debug statistics of received queue";
        uses appqoe-xe-oper:sipc-fifo-debug-stats;
      }  // container rx-debug-stats

      container err-stats {
        description
          "Error statistics of queues";
        uses appqoe-xe-oper:sipc-err-stats;
      }  // container err-stats
    }  // grouping appqoe-sipc-stats

    container appqoe-oper-data {
      config false;
      description
        "Application Quality of Experience (APPQOE)
       operational data";
      list appqoe-sc {
        key "sc-lan-ip";
        description
          "Application Quality of Experience (APPQOE)
         service controllers";
        uses appqoe-xe-oper:appqoe-sc;
      }  // list appqoe-sc

      container appqoe-nat-stats {
        presence "appqoe-nat-stats";
        description "APPQOE NAT statistics";
        uses appqoe-xe-oper:appqoe-nat-stats;
      }  // container appqoe-nat-stats

      container libsppi-stats {
        presence "libsppi-stats";
        description
          "APPQOE service plane packet interface (SPPI) statistics";
        uses appqoe-xe-oper:libsppi-stats;
      }  // container libsppi-stats

      container appqoe-rm-resources {
        presence "appqoe-rm-resources";
        description
          "APPQOE Resource Manager (RM) resources";
        uses appqoe-xe-oper:appqoe-rm-resources;
      }  // container appqoe-rm-resources

      container hput-stats {
        presence "hput-stats";
        description
          "APPQOE High Precision User Space Timer (HPUT) statistics";
        uses appqoe-xe-oper:hput-stats;
      }  // container hput-stats

      container appqoe-libuinet-stats {
        presence "appqoe-libuinet-stats";
        description
          "Application Quality of Experience (APPQOE)
         TCP/IP stack statistics";
        uses appqoe-xe-oper:appqoe-libuinet-stats;
      }  // container appqoe-libuinet-stats

      container rm-stats {
        presence "rm-stats";
        description
          "APPQOE Resource Manager (RM) statistics";
        uses appqoe-xe-oper:rm-stats;
      }  // container rm-stats

      list appqoe-ebp-stats {
        key "ebp-service-id";
        description "AppQoE EBP statistics";
        uses appqoe-xe-oper:appqoe-ebp-stats;
      }  // list appqoe-ebp-stats

      list appqoe-service {
        key "service";
        description "AppQoE service details";
        uses appqoe-types-ios-xe:appqoe-service;
      }  // list appqoe-service

      list appqoe-sipc-stats {
        key "service-id";
        description "AppQoE SIPC statistics";
        uses appqoe-xe-oper:appqoe-sipc-stats;
      }  // list appqoe-sipc-stats
    }  // container appqoe-oper-data
  }  // module Cisco-IOS-XE-appqoe-oper