module Cisco-IOS-XR-qos-ma-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-qos-ma-oper";

    prefix qos-ma-oper;

    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }

    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 module contains a collection of YANG definitions
     for Cisco IOS-XR qos-ma-oper package operational data.
     
     This module contains definitions
     for the following management objects:
       qos: QoS operational data
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-07-27" {
      description "IOS XR 7.3.1 revision.";
    }

    revision "2020-04-13" {
      description "IOS XR 7.3.1 revision.";
    }

    revision "2020-03-04" {
      description "IOS XR 7.2.1 revision.";
    }

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

    revision "2018-09-10" {
      description "IOS XR 7.0.1 revision.";
    }

    revision "2017-09-13" {
      description "IOS XR 6.4.1 revision.";
    }

    revision "2017-04-10" {
      description "IOS XR 6.3.1 revision.";
    }

    revision "2016-11-11" {
      description "IOS XR 6.2.1 revision.";
    }

    revision "2016-03-03" {
      description "IOS XR 6.1.1 revision.";
    }

    semver:module-version "1.0.0";

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

    typedef Policy-param-unit {
      type enumeration {
        enum "policy-param-unit-invalid" {
          value 0;
          description
            "Data flow rate is invalid";
        }
        enum "policy-param-unit-bytes" {
          value 1;
          description
            "Rate at which data flows in bytes";
        }
        enum "policy-param-unit-kbytes" {
          value 2;
          description
            "Rate at which data flows in kbytes";
        }
        enum "policy-param-unit-mbytes" {
          value 3;
          description
            "Rate at which data flows in mbytes";
        }
        enum "policy-param-unit-gbytes" {
          value 4;
          description
            "Rate at which data flows in gbytes";
        }
        enum "policy-param-unit-bitsps" {
          value 5;
          description
            "Rate at which data flows in bitsps";
        }
        enum "policy-param-unit-kbitsps" {
          value 6;
          description
            "Rate at which data flows in kbitsps";
        }
        enum "policy-param-unit-mbitsps" {
          value 7;
          description
            "Rate at which data flows in mbitsps";
        }
        enum "policy-param-unit-gbitsps" {
          value 8;
          description
            "Rate at which data flows in gbitsps";
        }
        enum "policy-param-unit-cells-ps" {
          value 9;
          description
            "Rate at which data flows in cells ps";
        }
        enum "policy-param-unit-packets-ps" {
          value 10;
          description
            "Rate at which data flows in packets ps";
        }
        enum "policy-param-unit-us" {
          value 11;
          description
            "Rate at which data flows in us";
        }
        enum "policy-param-unit-ms" {
          value 12;
          description
            "Rate at which data flows in ms";
        }
        enum "policy-param-unit-seconds" {
          value 13;
          description
            "Rate at which data flows in seconds";
        }
        enum "policy-param-unit-packets" {
          value 14;
          description
            "Rate at which data flows in packets";
        }
        enum "policy-param-unit-cells" {
          value 15;
          description
            "Rate at which data flows in cells";
        }
        enum "policy-param-unit-percent" {
          value 16;
          description
            "Rate at which data flows in percent";
        }
        enum
          "policy-param-unit-per-thousand" {
          value 17;
          description
            "Rate at which data flows in per thousand";
        }
        enum "policy-param-unit-per-million" {
          value 18;
          description
            "Rate at which data flows in per million";
        }
        enum "policy-param-unit-hz" {
          value 19;
          description
            "Rate at which data flows in hz";
        }
        enum "policy-param-unit-khz" {
          value 20;
          description
            "Rate at which data flows in khz";
        }
        enum "policy-param-unit-mhz" {
          value 21;
          description
            "Rate at which data flows in mhz";
        }
        enum "policy-param-unit-ratio" {
          value 22;
          description "Data flow unit ratio";
        }
        enum "policy-param-unit-max" {
          value 23;
          description
            "Maximum policy param unit ";
        }
      }
      description
        "Different units of measurement of Policy parameter";
    }

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

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

    typedef Qos-caps-operation-enum {
      type enumeration {
        enum "add" {
          value 0;
          description "Add Caps info";
        }
        enum "remove" {
          value 1;
          description "Remove Caps info";
        }
        enum "replace" {
          value 2;
          description
            "Replace the Caps info";
        }
        enum "modify" {
          value 3;
          description "Modify the Caps info";
        }
        enum "unknown" {
          value 4;
          description "Caps info is Unknown";
        }
      }
      description
        "Satellite QOS offload operation";
    }

    typedef Qos-ma-sat-caps-type-enum {
      type enumeration {
        enum "input" {
          value 0;
          description
            "Input satellite caps info";
        }
        enum "output" {
          value 1;
          description
            "Output satellite caps info";
        }
        enum "unknown" {
          value 2;
          description
            "Satellite Caps info Unknown";
        }
      }
      description
        "Satellite capsulation information";
    }

    typedef String-arr {
      type string;
      description "Array of strings";
    }

    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 "packets";
        description "CAC admitted packets";
      }

      leaf admit-bytes {
        type uint64;
        units "byte";
        description "CAC admitted bytes";
      }

      leaf admit-rates {
        type uint32;
        description "CAC admitted 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 "kbit/s";
        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 Wred;
        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
          "Police Packets classified according to color classification";
        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 Parameter Statistics for the queue length";
      leaf value {
        type uint32;
        description
          "value of the policy param stats";
      }

      leaf unit {
        type Policy-param-unit;
        description
          "unit of the policy param stats";
      }
    }  // 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
          "Rate of the packets that conform to the queue rate";
      }

      leaf exceed-rate {
        type uint32;
        description
          "Rate of the packets that exceed the queue rate";
      }

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

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

      list queue-max-length {
        description
          "Maximum length of the Queue";
        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 "packets";
        description
          "Total transmitted packets";
      }

      leaf transmit-bytes {
        type uint64;
        units "byte";
        description
          "Total transmitted bytes";
      }

      leaf total-drop-packets {
        type uint64;
        units "packets";
        description "Total dropped packets";
      }

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

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

      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;
        units "packets";
        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 CHILD-POLICY-CLASS-STATS {
      description
        "Classification of Child Service-policy Stats";
      container general-stats {
        description
          "general Child policy stats";
        uses GEN-STATS-ST;
      }  // container general-stats

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

      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 CHILD-POLICY-CLASS-STATS

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

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

      leaf state-description {
        type string {
          length "0..128";
        }
        description
          "Description of the state of child Qos Policy Stats";
      }

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

      list class-stats {
        description
          "array of classes contained in policy";
        uses CHILD-POLICY-CLASS-STATS;
      }  // list class-stats
    }  // grouping CHILD-POLICY-QOS-STATS

    grouping CLASS-STATS {
      description "Stats Classification";
      container general-stats {
        description
          "Stats classified as general statistics";
        uses GEN-STATS-ST;
      }  // container general-stats

      container iphc-stats {
        description
          "IP header compression statistic information stats";
        uses IPHC-STATS-ST;
      }  // container iphc-stats

      container child-policy {
        description
          "Qos child service-policy";
        uses CHILD-POLICY-QOS-STATS;
      }  // 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 state {
        type Policy-state;
        description "State";
      }

      leaf state-description {
        type string {
          length "0..128";
        }
        description
          "Description of the state of Qos Policy  Stats";
      }

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

      list class-stats {
        description
          "array of classes contained in policy";
        uses CLASS-STATS;
      }  // list class-stats
    }  // grouping QOS-STATS

    grouping QOS-MA-SAT-IF-EDM-INFO-XML {
      description
        "QoS offload information on Satellite interface";
      leaf policy-name {
        type string {
          length "0..65";
        }
        description "Service policy name";
      }

      leaf direction {
        type Qos-ma-sat-caps-type-enum;
        description "Satellite caps type";
      }

      leaf last-operation {
        type Qos-caps-operation-enum;
        description
          "Previous caps operation";
      }

      leaf status {
        type String-arr;
        description "Status of offload";
      }

      leaf error-message {
        type String-arr;
        description
          "Error message in case of failure";
      }
    }  // grouping QOS-MA-SAT-IF-EDM-INFO-XML

    grouping STATISTICS {
      description
        "Common node of input, output";
      container statistics {
        description
          "Policy-map statistics operational data for an
         interface";
        uses QOS-STATS;
      }  // container statistics
    }  // grouping STATISTICS

    grouping INTERFACE {
      description
        "Common node of interface-table,
       nv-interface-table";
      list interface {
        key "interface-name";
        description
          "QoS policy-map operational data for a particular
         interface";
        container nodes {
          description
            "QoS policy-map node table";
          list node {
            key "node-name";
            description
              "QoS operational data for a particular node";
            leaf node-name {
              type xr:Node-id;
              description "The node";
            }

            uses QOS-PI-OPER-INPUT;

            uses QOS-PI-OPER-OUTPUT;
          }  // list node
        }  // container nodes

        leaf interface-name {
          type xr:Interface-name;
          description
            "Name of the interface";
        }

        uses MEMBER-INTERFACE-TABLE;

        uses SATELLITE-ID-TABLE;

        uses QOS-PI-OPER-INPUT;

        uses QOS-PI-OPER-OUTPUT;
      }  // list interface
    }  // grouping INTERFACE

    grouping INPUT {
      description
        "Common node of member-interface,
       nv-satellite-interface";
      container input {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        uses STATUS;
      }  // container input
    }  // grouping INPUT

    grouping QOS-PI-OPER-INPUT {
      description
        "Common node of shared-policy-instance,
       member-interface, interface,
       nv-satellite-interface, satellite-id";
      container input {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        container service-policy-names {
          description
            "Operational data for all Policy instance";
          list service-policy-instance {
            key "service-policy-name";
            description
              "QoS policy-map operational data for a
             particular Policy ";
            leaf service-policy-name {
              type xr:Cisco-ios-xr-string;
              description
                "Name of the policy instance";
            }

            uses STATISTICS;
          }  // list service-policy-instance
        }  // container service-policy-names
      }  // container input
    }  // grouping QOS-PI-OPER-INPUT

    grouping QOS-PI-OPER-SPI-INPUT {
      description
        "Grouping to display SPI input stats";
      container input {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        uses STATISTICS;
      }  // container input
    }  // grouping QOS-PI-OPER-SPI-INPUT

    grouping VO-Q-STATS {
      description
        "Common node of locationvo-q, output-vo-q,
       vo-qoutput";
      container vo-q-stats {
        description
          "VoQ statistics operational data for an interface";
        uses QOS-STATS;
      }  // container vo-q-stats
    }  // grouping VO-Q-STATS

    grouping MEMBER-INTERFACE-TABLE {
      description
        "Common node of interface, nv-satellite-interface,
       shared-policy-instance";
      container member-interfaces {
        description
          "QoS policy-map member interface table";
        list member-interface {
          key "interface-name";
          description
            "QoS policy-map member interface statistics";
          leaf interface-name {
            type xr:Interface-name;
            description
              "Name of member interface";
          }

          uses SATELLITE-ID-TABLE;

          uses QOS-PI-OPER-INPUT;

          uses QOS-PI-OPER-OUTPUT;
        }  // list member-interface
      }  // container member-interfaces
    }  // grouping MEMBER-INTERFACE-TABLE

    grouping MEMBER-INTERFACE-SPI-TABLE {
      description
        "Grouping to display SPI member stats";
      container member-interfaces {
        description
          "QoS policy-map member interface table";
        list member-interface {
          key "interface-name";
          description
            "QoS policy-map member interface statistics";
          leaf interface-name {
            type xr:Interface-name;
            description
              "Name of member interface";
          }

          uses STATISTICS;

          uses QOS-PI-OPER-SPI-INPUT;

          uses QOS-PI-OPER-SPI-OUTPUT;
        }  // list member-interface
      }  // container member-interfaces
    }  // grouping MEMBER-INTERFACE-SPI-TABLE

    grouping STATUS {
      description
        "Common node of input, output,
       nv-satellite-interface";
      container status {
        description
          "Policy-map status operational data for an
         interface";
        uses QOS-MA-SAT-IF-EDM-INFO-XML;
      }  // container status
    }  // grouping STATUS

    grouping INTERFACE-TABLE {
      description
        "Common node of qos, policy-map";
      container interface-table {
        description
          "Operational data for all interfaces";
        uses INTERFACE;
      }  // container interface-table
    }  // grouping INTERFACE-TABLE

    grouping OUTPUT {
      description
        "Common node of member-interface,
       nv-satellite-interface";
      container output {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        uses STATUS;
      }  // container output
    }  // grouping OUTPUT

    grouping QOS-PI-OPER-SPI-OUTPUT {
      description
        "Grouping to display SPI output stats";
      container output {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        uses STATISTICS;
      }  // container output
    }  // grouping QOS-PI-OPER-SPI-OUTPUT

    grouping QOS-PI-OPER-OUTPUT {
      description
        "Common node of shared-policy-instance,
       member-interface, interface,
       nv-satellite-interface, satellite-id";
      container output {
        description
          "A piece of QoS policy-map operational data for
         an interface";
        container service-policy-names {
          description
            "Operational data for all Policy instance";
          list service-policy-instance {
            key "service-policy-name";
            description
              "QoS policy-map operational data for a
             particular Policy ";
            leaf service-policy-name {
              type xr:Cisco-ios-xr-string;
              description
                "Name of the policy instance";
            }

            uses STATISTICS;
          }  // list service-policy-instance
        }  // container service-policy-names
      }  // container output
    }  // grouping QOS-PI-OPER-OUTPUT

    grouping SATELLITE-ID-TABLE {
      description
        "Common node of interface, member-interface";
      container satellite-ids {
        description
          "Satellite ID information";
        list satellite-id {
          key "nv-satellite-id";
          description
            "Satellite ID information";
          leaf nv-satellite-id {
            type int32 {
              range "100..60000";
            }
            description "Satellite ID";
          }

          uses QOS-PI-OPER-INPUT;

          uses QOS-PI-OPER-OUTPUT;
        }  // list satellite-id
      }  // container satellite-ids
    }  // grouping SATELLITE-ID-TABLE

    container qos {
      config false;
      description "QoS operational data";
      container nv-interface-table {
        description
          "Operational data for satellite interfaces";
        uses INTERFACE;
      }  // container nv-interface-table

      container nv-satellite {
        description "Satellite table";
        container nv-satellite-statistics {
          description
            "Satellite statistics based on Satellite ID";
          container nv-satellite-ids {
            description "Satellite ID table";
            list nv-satellite-id {
              key "satellite-id";
              description
                "Satellite ID information";
              container nv-satellite-interfaces {
                description
                  "Operational data of satellite interface of a
                 particular satellite";
                list nv-satellite-interface {
                  key "interface-name";
                  description
                    "Operational data for a particular satellite
                   interface";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Name of the interface";
                  }

                  uses MEMBER-INTERFACE-TABLE;

                  uses QOS-PI-OPER-INPUT;

                  uses QOS-PI-OPER-OUTPUT;
                }  // list nv-satellite-interface
              }  // container nv-satellite-interfaces

              leaf satellite-id {
                type int32;
                description "Satellite ID";
              }
            }  // list nv-satellite-id
          }  // container nv-satellite-ids
        }  // container nv-satellite-statistics

        container nv-satellite-status {
          description
            "Satellite QOS offload status based on Satellite
           ID";
          container nv-satellite-ids {
            description "Satellite ID table";
            list nv-satellite-id {
              key "satellite-id";
              description
                "Satellite ID information";
              container nv-satellite-interfaces {
                description
                  "QOS offload status of satellite interface of
                 a particular satellite";
                list nv-satellite-interface {
                  key "interface-name";
                  description
                    "QOS offload status for a particular
                   satellite interface";
                  container member-interfaces {
                    description
                      "Satellite member interface table";
                    list member-interface {
                      key "interface-name";
                      description
                        "Satellite member interface statistics";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Name of member interface";
                      }

                      uses INPUT;

                      uses OUTPUT;
                    }  // list member-interface
                  }  // container member-interfaces

                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Name of the interface";
                  }

                  uses INPUT;

                  uses STATUS;

                  uses OUTPUT;
                }  // list nv-satellite-interface
              }  // container nv-satellite-interfaces

              leaf satellite-id {
                type int32;
                description "Satellite ID";
              }
            }  // list nv-satellite-id
          }  // container nv-satellite-ids
        }  // container nv-satellite-status
      }  // container nv-satellite

      container nodes {
        description
          "Node-specific QoS operational data";
        list node {
          key "node-name";
          description
            "QoS operational data for a particular node";
          container policy-map {
            description
              "Operational data for policymaps";
            container shared-policy-instances {
              description
                "Operational data for all SPI";
              list shared-policy-instance {
                key "spi-name";
                description
                  "QoS policy-map operational data for a
                 particular SPI ";
                leaf spi-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Name of the shared policy instance";
                }

                uses QOS-PI-OPER-SPI-INPUT;

                uses QOS-PI-OPER-SPI-OUTPUT;

                uses MEMBER-INTERFACE-SPI-TABLE;
              }  // list shared-policy-instance
            }  // container shared-policy-instances

            uses INTERFACE-TABLE;
          }  // container policy-map

          leaf node-name {
            type xr:Node-id;
            description "The node";
          }
        }  // list node
      }  // container nodes

      container qos-global {
        description
          "For global registrations";
        container vo-q {
          description
            "For VoQ operational data";
          container vo-q-statistics {
            description "For VoQ statistics";
            container vo-qinterfaces {
              description
                " For VoQ interface";
              list vo-qinterface {
                key "interface-name";
                description
                  "QoS policy-map operational data for a
                 particular interface";
                container output-vo-q {
                  description
                    "output VoQ interface";
                  container locationvo-qs {
                    description
                      "QoS policy-map location table";
                    list locationvo-q {
                      key "node-name";
                      description
                        "QoS operational data for a particular
                       location";
                      leaf node-name {
                        type xr:Node-id;
                        description
                          "The node";
                      }

                      uses VO-Q-STATS;
                    }  // list locationvo-q
                  }  // container locationvo-qs

                  container service-policy-names {
                    description
                      "Operational data for all Policy instance";
                    list service-policy-instance {
                      key "service-policy-name";
                      description
                        "QoS policy-map operational data for a
                       particular Policy ";
                      leaf service-policy-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "Name of the policy instance";
                      }

                      uses VO-Q-STATS;
                    }  // list service-policy-instance
                  }  // container service-policy-names
                }  // container output-vo-q

                container vo-q-member-interfaces {
                  description
                    "VoQ QoS policy-map member interface table";
                  list vo-q-member-interface {
                    key "interface-name";
                    description
                      "QoS policy-map member interface statistics";
                    container vo-qoutput {
                      description
                        "output VoQ interface";
                      container service-policy-names {
                        description
                          "Operational data for all Policy instance";
                        list service-policy-instance {
                          key "service-policy-name";
                          description
                            "QoS policy-map operational data for a
                           particular Policy ";
                          leaf service-policy-name {
                            type xr:Cisco-ios-xr-string;
                            description
                              "Name of the policy instance";
                          }

                          uses VO-Q-STATS;
                        }  // list service-policy-instance
                      }  // container service-policy-names
                    }  // container vo-qoutput

                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Name of member interface";
                    }
                  }  // list vo-q-member-interface
                }  // container vo-q-member-interfaces

                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Name of the interface";
                }
              }  // list vo-qinterface
            }  // container vo-qinterfaces
          }  // container vo-q-statistics
        }  // container vo-q
      }  // container qos-global

      uses INTERFACE-TABLE;
    }  // container qos
  }  // module Cisco-IOS-XR-qos-ma-oper