submodule Cisco-IOS-XR-asr9k-qos-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-asr9k-qos-oper {
        prefix Cisco-IOS-XR-asr9k-qos-oper;
    }

    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR asr9k-qos package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-04-09" {
      description
        "pi changes to support wred drop probability";
    }

    revision "2020-12-23" {
      description
        "Introduced an CLI to show qos performance stats";
    }

    revision "2019-09-30" {
      description
        "YANG support for PWHE interface";
    }

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.0";

    typedef Wred1 {
      type enumeration {
        enum "wred-cos-cmd" {
          value 0;
          description "wred cos cmd";
        }
        enum "wred-dscp-cmd" {
          value 1;
          description "wred dscp cmd";
        }
        enum "wred-precedence-cmd" {
          value 2;
          description "wred precedence cmd";
        }
        enum "wred-discard-class-cmd" {
          value 3;
          description
            "wred discard class cmd";
        }
        enum "wred-mpls-exp-cmd" {
          value 4;
          description "wred mpls exp cmd";
        }
        enum "red-with-user-min-max" {
          value 5;
          description
            "red with user min max";
        }
        enum "red-with-default-min-max" {
          value 6;
          description
            "red with default min max";
        }
        enum "wred-dei-cmd" {
          value 7;
          description "wred dei cmd";
        }
        enum "wred-ecn-cmd" {
          value 8;
          description "wred ecn cmd";
        }
        enum "wred-invalid-cmd" {
          value 9;
          description "wred invalid cmd";
        }
      }
      description "Wred1";
    }

    typedef Policy-param-unit {
      type enumeration {
        enum "policy-param-unit-invalid" {
          value 0;
          description
            "policy param unit invalid";
        }
        enum "policy-param-unit-bytes" {
          value 1;
          description
            "policy param unit bytes";
        }
        enum "policy-param-unit-kbytes" {
          value 2;
          description
            "policy param unit kbytes";
        }
        enum "policy-param-unit-mbytes" {
          value 3;
          description
            "policy param unit mbytes";
        }
        enum "policy-param-unit-gbytes" {
          value 4;
          description
            "policy param unit gbytes";
        }
        enum "policy-param-unit-bitsps" {
          value 5;
          description
            "policy param unit bitsps";
        }
        enum "policy-param-unit-kbitsps" {
          value 6;
          description
            "policy param unit kbitsps";
        }
        enum "policy-param-unit-mbitsps" {
          value 7;
          description
            "policy param unit mbitsps";
        }
        enum "policy-param-unit-gbitsps" {
          value 8;
          description
            "policy param unit gbitsps";
        }
        enum "policy-param-unit-cells-ps" {
          value 9;
          description
            "policy param unit cells ps";
        }
        enum "policy-param-unit-packets-ps" {
          value 10;
          description
            "policy param unit packets ps";
        }
        enum "policy-param-unit-us" {
          value 11;
          description "policy param unit us";
        }
        enum "policy-param-unit-ms" {
          value 12;
          description "policy param unit ms";
        }
        enum "policy-param-unit-seconds" {
          value 13;
          description
            "policy param unit seconds";
        }
        enum "policy-param-unit-packets" {
          value 14;
          description
            "policy param unit packets";
        }
        enum "policy-param-unit-cells" {
          value 15;
          description
            "policy param unit cells";
        }
        enum "policy-param-unit-percent" {
          value 16;
          description
            "policy param unit percent";
        }
        enum
          "policy-param-unit-per-thousand" {
          value 17;
          description
            "policy param unit per thousand";
        }
        enum "policy-param-unit-per-million" {
          value 18;
          description
            "policy param unit per million";
        }
        enum "policy-param-unit-hz" {
          value 19;
          description "policy param unit hz";
        }
        enum "policy-param-unit-khz" {
          value 20;
          description
            "policy param unit khz";
        }
        enum "policy-param-unit-mhz" {
          value 21;
          description
            "policy param unit mhz";
        }
        enum "policy-param-unit-ratio" {
          value 22;
          description
            "policy param unit ratio";
        }
        enum
          "policy-param-unit-inverse-ratio" {
          value 23;
          description
            "policy param unit inverse ratio";
        }
        enum "policy-param-unit-max" {
          value 24;
          description
            "policy param unit max";
        }
      }
      description "Policy param unit";
    }

    typedef Cac-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "unknown";
        }
        enum "admit" {
          value 1;
          description "admit";
        }
        enum "redirect" {
          value 2;
          description "redirect";
        }
        enum "ubrl" {
          value 3;
          description "ubrl";
        }
      }
      description "CAC/UBRL class states";
    }

    typedef Policy-state {
      type enumeration {
        enum "active" {
          value 0;
          description "active";
        }
        enum "suspended" {
          value 1;
          description "suspended";
        }
      }
      description
        "Different Interface states";
    }

    grouping CAC-STATS-ST {
      description "CAC statistics";
      leaf drop-packets {
        type uint64;
        description "CAC dropped packets";
      }

      leaf drop-bytes {
        type uint64;
        units "byte";
        description "CAC dropped bytes";
      }

      leaf drop-rates {
        type uint32;
        description "CAC dropped rate";
      }

      leaf admitpackets {
        type uint64;
        units "byte";
        description
          "Admitted packets (pkts/bytes)";
      }

      leaf admit-bytes {
        type uint64;
        units "byte";
        description
          "Admitted bytes (pkts/bytes)";
      }

      leaf admit-rates {
        type uint32;
        description "CAC admit rate";
      }
    }  // grouping CAC-STATS-ST

    grouping IPHC-STATS-ST {
      description "IPHC Stats";
      leaf non-tcp-total-out-packets {
        type uint64;
        description
          "TotalNum of Non tcp pkts sent";
      }

      leaf non-tcp-total-out-bytes {
        type uint64;
        units "byte";
        description
          "TotalNum of Non Tcp Bytes sent";
      }

      leaf non-tcp-bytes-saved {
        type uint64;
        units "byte";
        description
          "Non Tcp Bytes saved due to compression";
      }

      leaf non-tcp-compressed-packets-out {
        type uint64;
        description
          "Num of non tcp compressed pkts sent";
      }

      leaf non-tcp-bytes-sent-rate {
        type uint32;
        units "byte";
        description
          "Compressed Non Tcp Bytes sent rate";
      }

      leaf non-tcp-full-header-packets-out {
        type uint64;
        description
          "Num of non tcp fullheader pkts sent";
      }

      leaf tcp-total-out-packets {
        type uint64;
        description
          "Total Num of tcp pkts sent";
      }

      leaf tcp-total-out-bytes {
        type uint64;
        units "byte";
        description
          "TotalNum of Tcp Bytes sent";
      }

      leaf tcp-bytes-saved {
        type uint64;
        units "byte";
        description
          "Tcp Bytes saved due to compression";
      }

      leaf tcp-compressed-packets-out {
        type uint64;
        description
          "Num of tcp compressed pkts sent";
      }

      leaf tcp-bytes-sent-rate {
        type uint32;
        units "byte";
        description
          "Compressed Tcp Bytes sent rate";
      }

      leaf tcp-full-header-packets-out {
        type uint64;
        description
          "Num of tcp fullheader pkts sent";
      }
    }  // grouping IPHC-STATS-ST

    grouping WRED-TYPE-VALUE {
      description "WRED Type Value pairs";
      leaf wred-type {
        type Wred1;
        description
          "WRED type DSCP, EXP, PREC etc.";
      }

      leaf value {
        type uint8;
        description
          "WRED value for this type.";
      }
    }  // grouping WRED-TYPE-VALUE

    grouping RED-PROFILE-STATS {
      description "Per RED profile stats";
      leaf profile-title {
        type string {
          length "0..300";
        }
        description "ProfileTitle";
      }

      leaf red-transmit-packets {
        type uint64;
        description "Transmitted packets";
      }

      leaf red-transmit-bytes {
        type uint64;
        units "byte";
        description "Transmitted bytes";
      }

      leaf random-drop-packets {
        type uint64;
        description
          "Probabilistically dropped  packets";
      }

      leaf random-drop-bytes {
        type uint64;
        units "byte";
        description
          "Probabilisticallydropped bytes";
      }

      leaf max-threshold-packets {
        type uint64;
        description
          "Dropped packets with  the average queue size at
         the max-threshold";
      }

      leaf max-threshold-bytes {
        type uint64;
        units "byte";
        description
          "Dropped bytes with  the average queue size at
         the max-threshold";
      }

      leaf red-ecn-marked-packets {
        type uint64;
        description "ECN marked packets ";
      }

      leaf red-ecn-marked-bytes {
        type uint64;
        units "byte";
        description "ECN marked bytes";
      }

      list red-label {
        description
          "Array of WRED Typevalues as in PRP stats is
         available per threshold   ";
        uses WRED-TYPE-VALUE;
      }  // list red-label
    }  // grouping RED-PROFILE-STATS

    grouping PLC-COLOR-CLASS-STATS-ST {
      description
        "Color Aware Policer statistics";
      leaf conform-class-conform-packets {
        type uint64;
        description
          "Packets with classification result conform and
         policer result conform";
      }

      leaf conform-class-conform-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result conform and
         policer result conform";
      }

      leaf conform-class-conform-rate {
        type uint32;
        units "kbit/s";
        description
          "Conform Class Conform rate in kbps";
      }

      leaf conform-class-exceed-packets {
        type uint64;
        description
          "Packets with classification result conform and
         policer result exceed";
      }

      leaf conform-class-exceed-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result conform and
         policer result exceed";
      }

      leaf conform-class-exceed-rate {
        type uint32;
        units "kbit/s";
        description
          "Conform Class Exceed rate in kbps";
      }

      leaf conform-class-violate-packets {
        type uint64;
        description
          "Packets with classification result conform and
         policer result violate";
      }

      leaf conform-class-violate-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result conform and
         policer result violate";
      }

      leaf conform-class-violate-rate {
        type uint32;
        units "kbit/s";
        description
          "Conform Class Violate rate in kbps";
      }

      leaf exceed-class-exceed-packets {
        type uint64;
        description
          "Packets with classification result exceed and
         policer result exceed";
      }

      leaf exceed-class-exceed-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result exceed and
         policer result exceed";
      }

      leaf exceed-class-exceed-rate {
        type uint32;
        units "kbit/s";
        description
          "Exceed Class Exceed rate in kbps";
      }

      leaf exceed-class-violate-packets {
        type uint64;
        description
          "Packets with classification result exceed and
         policer result violate";
      }

      leaf exceed-class-violate-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result exceed and
         policer result violate";
      }

      leaf exceed-class-violate-rate {
        type uint32;
        units "kbit/s";
        description
          "Exceed Class Violate rate in kbps";
      }

      leaf violate-class-violate-packets {
        type uint64;
        description
          "Packets with classification result violate and
         policer result violate";
      }

      leaf violate-class-violate-bytes {
        type uint64;
        units "byte";
        description
          "Bytes with classification result violate and
         policer result violate";
      }

      leaf violate-class-violate-rate {
        type uint32;
        units "kbit/s";
        description
          "Violate Class Violate rate in kbps";
      }
    }  // grouping PLC-COLOR-CLASS-STATS-ST

    grouping PLC-STATS-ST {
      description "Policer statistics";
      container color-class-stats {
        description "color class stats";
        uses PLC-COLOR-CLASS-STATS-ST;
      }  // container color-class-stats

      leaf drop-packets {
        type uint64;
        description "Police dropped packets";
      }

      leaf drop-bytes {
        type uint64;
        units "byte";
        description "Police dropped bytes";
      }

      leaf conform-packets {
        type uint64;
        description
          "Packets that conform  to the policed rate";
      }

      leaf conform-bytes {
        type uint64;
        units "byte";
        description
          "Bytes that conform to the policed rate";
      }

      leaf exceed-packets {
        type uint64;
        description
          "Packets that exceed the policed rate";
      }

      leaf exceed-bytes {
        type uint64;
        units "byte";
        description
          "Bytes that exceed  the policed rate";
      }

      leaf violate-packets {
        type uint64;
        description
          "Packets violating the policed rate";
      }

      leaf violate-bytes {
        type uint64;
        units "byte";
        description
          "Bytes that violate the policed rate";
      }

      leaf parent-drop-packets {
        type uint64;
        description
          "Dropped pkts by the parent policer";
      }

      leaf parent-drop-bytes {
        type uint64;
        units "byte";
        description
          "Dropped bytes by the parent policer";
      }

      leaf conform-rate {
        type uint32;
        units "kbit/s";
        description "Conform rate in kbps";
      }

      leaf exceed-rate {
        type uint32;
        units "kbit/s";
        description "Exceed rate in kbps";
      }

      leaf violate-rate {
        type uint32;
        units "kbit/s";
        description "Violate rate in kbps";
      }
    }  // grouping PLC-STATS-ST

    grouping POLICY-PARAM-UINT32-ST {
      description "POLICY PARAM UINT32 ST";
      leaf value {
        type uint32;
        description "value";
      }

      leaf unit {
        type Policy-param-unit;
        description "unit";
      }
    }  // grouping POLICY-PARAM-UINT32-ST

    grouping Q-STATS-ST {
      description "Queue limit statistics";
      leaf queue-id {
        type uint32;
        description
          "Queue Id used for Fabric Stats";
      }

      leaf tail-drop-packets {
        type uint64;
        description "Packets tail dropped";
      }

      leaf tail-drop-bytes {
        type uint64;
        units "byte";
        description "Bytes tail dropped";
      }

      leaf atm-clp0-drop-packets {
        type uint64;
        description
          "ATP CLP 0 matched packets dropped";
      }

      leaf atm-clp0-drop-bytes {
        type uint64;
        units "byte";
        description
          "ATP CLP 0 matched bytes dropped";
      }

      leaf atm-clp1-drop-packets {
        type uint64;
        description
          "ATP CLP 0 matched packets dropped";
      }

      leaf atm-clp1-drop-bytes {
        type uint64;
        units "byte";
        description
          "ATP CLP 0 matched bytes dropped";
      }

      leaf queue-drop-threshold {
        type uint32;
        units "byte";
        description
          "tail drop threshold of the queue in bytes";
      }

      leaf forced-wred-stats-display {
        type boolean;
        description
          "flag to forcedisplay of WRED even when per
         WredWRED profile stats is not available";
      }

      leaf random-drop-packets {
        type uint64;
        description
          "Packets probabilistically dropped";
      }

      leaf random-drop-bytes {
        type uint64;
        units "byte";
        description
          "Bytes probabilistically dropped";
      }

      leaf max-threshold-packets {
        type uint64;
        description
          "Dropped packets with the average queue size at
         the max-threshold";
      }

      leaf max-threshold-bytes {
        type uint64;
        units "byte";
        description
          "Dropped bytes with the average queue size at the
         max-threshold";
      }

      leaf conform-packets {
        type uint64;
        description
          "Packets that conform  to the queue rate";
      }

      leaf conform-bytes {
        type uint64;
        units "byte";
        description
          "Bytes that conform to the queue rate";
      }

      leaf exceed-packets {
        type uint64;
        description
          "Packets that exceed the queue rate";
      }

      leaf exceed-bytes {
        type uint64;
        units "byte";
        description
          "Bytes that exceed  the queue rate";
      }

      leaf conform-rate {
        type uint32;
        description "Conform rate";
      }

      leaf exceed-rate {
        type uint32;
        description "Exceed rate";
      }

      list queue-instance-length {
        description "Queue instance length";
        uses POLICY-PARAM-UINT32-ST;
      }  // list queue-instance-length

      list queue-average-length {
        description "Queue average length";
        uses POLICY-PARAM-UINT32-ST;
      }  // list queue-average-length

      list queue-max-length {
        description "Queue maximum length";
        uses POLICY-PARAM-UINT32-ST;
      }  // list queue-max-length
    }  // grouping Q-STATS-ST

    grouping GEN-STATS-ST {
      description
        "Counters common to all features";
      leaf transmit-packets {
        type uint64;
        units "byte";
        description
          "Transmitted packets (packets/bytes)";
      }

      leaf transmit-bytes {
        type uint64;
        units "byte";
        description
          "Transmitted bytes (packets/bytes)";
      }

      leaf total-drop-packets {
        type uint64;
        units "byte";
        description
          "Dropped packets (packets/bytes)";
      }

      leaf total-drop-bytes {
        type uint64;
        units "byte";
        description
          "Dropped bytes (packets/bytes)";
      }

      leaf total-drop-rate {
        type uint32;
        units "byte";
        description
          "Total drop rate (packets/bytes)";
      }

      leaf match-data-rate {
        type uint32;
        units "kbit/s";
        description
          "Incoming matched data rate in kbps";
      }

      leaf total-transmit-rate {
        type uint32;
        units "kbit/s";
        description
          "Total transmit rate in kbps";
      }

      leaf pre-policy-matched-packets {
        type uint64;
        description
          "Matched pkts before applying policy";
      }

      leaf pre-policy-matched-bytes {
        type uint64;
        units "byte";
        description
          "Matched bytes before applying policy";
      }
    }  // grouping GEN-STATS-ST

    grouping CLASS-STATS {
      description "CLASS STATS";
      container general-stats {
        description "general stats";
        uses GEN-STATS-ST;
      }  // container general-stats

      container iphc-stats {
        description "IPHC stats";
        uses IPHC-STATS-ST;
      }  // container iphc-stats

      container child-policy {
        description "child policy";
      }  // container child-policy

      container cac-stats {
        description "bag for cac stats";
        uses CAC-STATS-ST;
      }  // container cac-stats

      leaf counter-validity-bitmask {
        type uint64;
        units "megabyte";
        description
          " Bitmask to indicate which counter or counters
         are undetermined. Counters will be marked
         undetermined when one or more classes share
         queues with class-default because in such cases
         the value of counters for each class is invalid.
         Based on the flag(s) set, the following counters
         will be marked undetermined. For example, if
         value of this object returned is 0x00000101,
         counters
         TransmitPackets/TransmitBytes/TotalTransmitRate
         and DropPackets/DropBytes are undetermined
         .0x00000001 - Transmit
         (TransmitPackets/TransmitBytes/TotalTransmitRate
         ), 0x00000002 - Total drop
         (TotalDropPackets/TotalDropBytes/TotalDropRate),
         0x00000004 - Match
         (MatchDataRate/PrepolicyMatchedPackets
         /PrepolicyMatchedBytes), 0x00000100 - Police
         drop (DropPackets/DropBytes), 0x00000200 -
         Police conform
         (ConformPackets/ConformBytes/ConformRate),
         0x00000400 - Police exceed
         (ExceedPackets/ExceedBytes/ExceedRate),
         0x00000800 - Police violate
         (ViolatePackets/ViolateBytes/ViolateRate),
         0x00001000 - Parent policer drop
         (ParentDropPackets/ParentDropBytes), 0x00010000
         - Queueing drop (TailDropPackets/TailDropBytes),
         0x00020000 - Red queue drop
         (RandomDropPackets/RandomDropBytes), 0x00040000
         - Queue maximum threshold drop
         (MaxThresholdPackets/MaxThresholdBytes),
         0x00080000 - Queue conform
         (ConformPackets/ConformBytes/ConformRate),
         0x00100000 - Queue exceed
         (ExceedPackets/ExceedBytes/ExceedRate),
         0x00200000 - CLP limit drop
         (ATM_CLP0DropPackets/ATM_CLP0DropBytes
         /ATM_CLP1DropPackets/ATM_CLP1DropBytes),
         0x01000000 - RED transmit
         (RedTransmitPackets/RedTransmitBytes),
         0x02000000 - RED drop
         (RandomDropPackets/RandomDropBytes), 0x04000000
         - RED maximum threshold drop
         (MaxThresholdPackets/MaxThresholdBytes)";
      }

      leaf class-name {
        type string {
          length "0..65";
        }
        description "ClassName";
      }

      leaf shared-queue-id {
        type uint32;
        description
          "q-id of the  shared queue for this class";
      }

      leaf queue-descr {
        type string {
          length "0..256";
        }
        description
          "Description of queue for the class";
      }

      leaf cac-state {
        type Cac-state;
        description "CACState";
      }

      list queue-stats-array {
        description "array of queue stats";
        uses Q-STATS-ST;
      }  // list queue-stats-array

      list police-stats-array {
        description "array of police stats";
        uses PLC-STATS-ST;
      }  // list police-stats-array

      list wred-stats-array {
        description "array of red stats";
        uses RED-PROFILE-STATS;
      }  // list wred-stats-array
    }  // grouping CLASS-STATS

    grouping QOS-STATS {
      description "policy map statistics";
      leaf policy-name {
        type string {
          length "0..65";
        }
        description "PolicyName";
      }

      leaf subscriber-group {
        type string {
          length "0..34";
        }
        description "SubscriberGroup";
      }

      leaf state {
        type Policy-state;
        description "State";
      }

      leaf state-description {
        type string {
          length "0..128";
        }
        description "StateDescription";
      }

      leaf satid {
        type uint32;
        description
          "to maintain satellite id";
      }

      leaf policy-timestamp {
        type uint64;
        description "per policy timestamp";
      }

      list class-stat {
        description
          "array of classes contained in policy";
        uses CLASS-STATS;
      }  // list class-stat
    }  // grouping QOS-STATS
  }  // submodule Cisco-IOS-XR-asr9k-qos-oper-sub1