module Cisco-IOS-XR-snmp-agent-oper {

    yang-version 1;

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

    prefix snmp-agent-oper;

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

    include Cisco-IOS-XR-snmp-agent-oper-sub7 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub6 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub5 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub4 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub3 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub2 {
      revision-date "2020-09-15";
    }
    include Cisco-IOS-XR-snmp-agent-oper-sub1 {
      revision-date "2020-09-15";
    }

    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 snmp-agent package operational data.

This module contains definitions
for the following management objects:
  snmp: SNMP operational data

Copyright (c) 2013-2020 by Cisco Systems, Inc.
All rights reserved.";

    revision "2020-09-15" {
      description
        "Updated oper path for show snmp traps details";
    }

    revision "2020-03-31" {
      description
        "Fixing backward compatibility error in module.";
    }

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

    revision "2018-07-20" {
      description
        "Fixed English plural name transformation error.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2016-06-01" {
      description "IOS XR 6.0.1 revision.";
    }

    revision "2015-01-07" {
      description "IOS XR 5.3.1 revision.";
    }

    semver:module-version "2.0.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    container snmp {
      config false;
      description "SNMP operational data";
      container trap-servers {
        description "List of trap hosts";
        list trap-server {
          description
            "Trap server and port to which the trap is to be
sent and statistics";
          leaf trap-host {
            type string;
            description "Trap Host";
          }

          leaf port {
            type inet:port-number;
            description "Trap port";
          }

          leaf number-of-pkts-in-trap-q {
            type uint32;
            description
              "No. of trap packets in trapQ";
          }

          leaf max-q-length-of-trap-q {
            type uint32;
            description
              "Maximum Queue length of trapQ";
          }

          leaf number-of-pkts-sent {
            type uint32;
            description
              "No. of trap packets sent";
          }

          leaf number-of-pkts-dropped {
            type uint32;
            description
              "No. of trap packets dropped";
          }
        }  // list trap-server
      }  // container trap-servers

      container information {
        description
          "SNMP operational information";
        container hosts {
          description
            "SNMP host information";
          list host {
            key "name";
            description
              "SNMP target host name";
            leaf name {
              type xr:Cisco-ios-xr-string;
              description "Group name";
            }

            list host-information {
              key "user";
              description
                "Host name ,udp-port , user, security model
and level";
              leaf user {
                type xr:Cisco-ios-xr-string;
                description "SNMP host user";
              }

              leaf snmp-target-address-t-host {
                type string;
                description
                  "Transport type of address";
              }

              leaf snmp-target-address-port {
                type string;
                description
                  "Target UDP port";
              }

              leaf snmp-target-addresstype {
                type string;
                description
                  "Target host type (Inform or Trap)";
              }

              leaf snmp-target-params-security-model {
                type string;
                description "Security model";
              }

              leaf snmp-target-params-security-name {
                type string;
                description "Security name";
              }

              leaf snmp-target-params-security-level {
                type string;
                description "Security level";
              }
            }  // list host-information
          }  // list host
        }  // container hosts

        container system-up-time {
          description "System up time";
          leaf system-up-time-edm {
            type string;
            description
              "sysUpTime  1.3.6.1.2.1.1.3";
          }
        }  // container system-up-time

        container sub-agent-names {
          description
            "SNMP sub-agent details";
          list sub-agent-name {
            key "sub-agent-name";
            description "Subagent Name";
            leaf sub-agent-name {
              type xr:Cisco-ios-xr-string;
              description "Subagent Name";
            }

            leaf sub-agent-group {
              type string;
              description
                "Snmp SubAgent Name";
            }

            leaf sub-agent-client-id {
              type uint16;
              description
                "Client ID of SubAgent";
            }

            leaf mib-count {
              type uint16;
              description
                "Total Number of MIB in each SubAgent";
            }
          }  // list sub-agent-name
        }  // container sub-agent-names

        container nms-addresses {
          description
            "SNMP request type summary ";
          list nms-address {
            key "nms-addr";
            description "NMS address";
            leaf nms-addr {
              type xr:Cisco-ios-xr-string;
              description "NMS address";
            }

            leaf nms-address {
              type string;
              description
                "NMS address of server";
            }

            leaf get-request-count {
              type uint32;
              description
                "Get Request Count";
            }

            leaf getnext-request-count {
              type uint32;
              description
                "Getnext Request Count";
            }

            leaf getbulk-request-count {
              type uint32;
              description
                "Getbulk Request Count";
            }

            leaf set-request-count {
              type uint32;
              description
                "Set Request Count";
            }

            leaf test-request-count {
              type uint32;
              description
                "Test Request Count";
            }
          }  // list nms-address
        }  // container nms-addresses

        container engine-id {
          description "SNMP engine ID";
          leaf engine-id {
            type string;
            description "SNMPv3 engineID";
          }
        }  // container engine-id

        container sub-agent-group-names {
          description
            "SNMP sub-agent details";
          list sub-agent-group-name {
            key "sub-agent-group-name";
            description
              "Subagent Group Name";
            leaf sub-agent-group-name {
              type xr:Cisco-ios-xr-string;
              description
                "Subagent Group Name";
            }

            leaf sub-agent-group {
              type string;
              description
                "Snmp SubAgent name";
            }

            leaf sub-agent-client-id {
              type uint16;
              description
                "Client ID of SubAgent";
            }

            leaf mib-count {
              type uint16;
              description
                "Total Number of MIB in each SubAgent";
            }

            list mib-detail {
              description
                "MIB details (MIB name, OID count and Object
Names)";
              leaf mib-name {
                type string;
                description
                  "Name of the SubAgent MIB module";
              }

              list mib-object-name {
                description
                  "Object Names in MIB";
                leaf object-name {
                  type string;
                  description
                    "Name of MIB object";
                }
              }  // list mib-object-name
            }  // list mib-detail
          }  // list sub-agent-group-name
        }  // container sub-agent-group-names

        container rx-queue {
          description
            "SNMP rx queue statistics";
          leaf qlen {
            type uint32;
            description "qlen";
          }

          leaf in-min {
            type uint32;
            description "in min";
          }

          leaf in-avg {
            type uint32;
            description "in avg";
          }

          leaf in-max {
            type uint32;
            description "in max";
          }

          leaf pend-min {
            type uint32;
            description "pend min";
          }

          leaf pend-avg {
            type uint32;
            description "pend avg";
          }

          leaf pend-max {
            type uint32;
            description "pend max";
          }

          list incoming-q {
            max-elements 300;
            description "incoming q";
            leaf min {
              type uint32;
              description "min";
            }

            leaf avg {
              type uint32;
              description "avg";
            }

            leaf max {
              type uint32;
              description "max";
            }
          }  // list incoming-q

          list pending-q {
            max-elements 300;
            description "pending q";
            leaf min {
              type uint32;
              description "min";
            }

            leaf avg {
              type uint32;
              description "avg";
            }

            leaf max {
              type uint32;
              description "max";
            }
          }  // list pending-q
        }  // container rx-queue

        container system-name {
          description "System name";
          leaf system-name {
            type string;
            description
              "sysName  1.3.6.1.2.1.1.5";
          }
        }  // container system-name

        container request-type-detail {
          description
            "SNMP request type details ";
          container nms-addresses {
            description
              "snmp request type details ";
            list nms-address {
              key "nms-addr";
              description "NMS address";
              leaf nms-addr {
                type xr:Cisco-ios-xr-string;
                description "NMS address";
              }

              leaf total-count {
                type uint32;
                description
                  "Total request count for each managment station
or client";
              }

              leaf agent-request-count {
                type uint32;
                description
                  "Processing agent request count for each client
for particluar managment station";
              }

              leaf interface-request-count {
                type uint32;
                description
                  "Processing interfce request count for each
client for particluar managment station";
              }

              leaf entity-request-count {
                type uint32;
                description
                  "Processing entity request count for each client
for particluar managment station";
              }

              leaf route-request-count {
                type uint32;
                description
                  "Processing route request count for each client
for particluar Managment station";
              }

              leaf infra-request-count {
                type uint32;
                description
                  "Processing infra request count for each client
for particluar Managment station";
              }
            }  // list nms-address
          }  // container nms-addresses
        }  // container request-type-detail

        container duplicate-drop {
          description
            "Duplicate request status, count, time ";
          leaf duplicate-request-status {
            type Dup-req-drop-status;
            description
              "Duplicate requests drop feature status.";
          }

          leaf last-status-change-time {
            type string;
            description
              "Duplicate request drop feature last enable
disable time (Day Mon Date HH:MM:SS)";
          }

          leaf duplicate-drop-configured-timeout {
            type uint32;
            description
              "Configured Duplicate Drop feature Timeout.";
          }

          leaf duplicate-dropped-requests {
            type uint32;
            description
              "Number of duplicate SNMP requests are dropped.";
          }

          leaf retry-processed-requests {
            type uint32;
            description
              "Number of Retry SNMP requests are Processed.";
          }

          leaf first-enable-time {
            type string;
            description
              "Duplicate request drop feature first  enable
time (Day Mon Date HH:MM:SS)";
          }

          leaf latest-duplicate-dropped-requests {
            type uint32;
            description
              "Number of duplicate SNMP requests dropped, from
the last enable time.";
          }

          leaf latest-retry-processed-requests {
            type uint32;
            description
              "Number of retry SNMP requests processed, from
the last enable time.";
          }

          leaf duplicate-request-latest-enable-time {
            type string;
            description
              "Duplicate request drop feature last enable
time(Day Mon Date HH:MM:SS)";
          }

          leaf duplicate-drop-enable-count {
            type uint32;
            description
              " Number of times duplicate request drop feature
is enabled.";
          }

          leaf duplicate-drop-disable-count {
            type uint32;
            description
              " Number of times duplicate request drop feature
is disabled.";
          }
        }  // container duplicate-drop

        container bulk-stats-transfers {
          description
            "List of bulkstats transfer on the system";
          list bulk-stats-transfer {
            key "transfer-name";
            description
              "SNMP bulkstats transfer name";
            leaf transfer-name {
              type xr:Cisco-ios-xr-string;
              description "Transfer name";
            }

            leaf transfer-name-xr {
              type string;
              description
                "Name of the bulkstats transfer session";
            }

            leaf url-primary {
              type string;
              description
                "Bulkstats transfer primary URL";
            }

            leaf url-secondary {
              type string;
              description
                "Bulkstats transfer secondary URL";
            }

            leaf retained-file {
              type string;
              description
                "Bulkstats transfer retained file name";
            }

            leaf time-left {
              type uint32;
              units "second";
              description
                "Bulkstats transfer retry time left in seconds";
            }

            leaf retry-left {
              type uint32;
              description
                "Bulkstats transfer retry attempt left";
            }
          }  // list bulk-stats-transfer
        }  // container bulk-stats-transfers

        container trap-infos {
          description "SNMP trap OID";
          list trap-info {
            description
              "SNMP Trap infomation like server , port and
trapOID";
            leaf trap-host {
              type string;
              description "Trap Host";
            }

            leaf port {
              type inet:port-number;
              description "Trap port";
            }

            leaf host {
              type string;
              description "NMS/Host address";
            }

            leaf port-xr {
              type uint16;
              description "udp port number";
            }

            leaf vrf-name {
              type string;
              description "vrf name";
            }

            leaf time {
              type uint32;
              description
                "Trap delay time Left";
            }

            leaf trap-oid-count {
              type uint32;
              description
                "Total number of OID's sent";
            }

            list trap-oi-dinfo {
              description
                "Per trap OID statistics";
              leaf trap-oid {
                type string;
                description "TRAP OID";
              }

              leaf count {
                type uint32;
                description
                  "Number of traps sent";
              }

              leaf drop-count {
                type uint32;
                description
                  "Number of Traps Dropped at InternalQ";
              }

              leaf drop-host-count {
                type uint32;
                description
                  "Number of Traps Dropped at HostQ";
              }

              leaf drop-delay-timer {
                type uint32;
                description
                  "Number of Traps Dropped due to trap delay timer
expiry";
              }

              leaf retry-count {
                type uint32;
                description
                  "Num of times retry";
              }

              leaf lastsent-time {
                type string;
                description
                  "Timestamp of latest successfully sent";
              }

              leaf lastdrop-time {
                type string;
                description
                  "Timestamp of latest dropped";
              }

              leaf last-hostdrop-time {
                type string;
                description
                  "Timestamp of latest dropped at host";
              }

              leaf last-host-delay-time {
                type string;
                description
                  "Timestamp of latest dropped due to delay timer
expiry";
              }
            }  // list trap-oi-dinfo
          }  // list trap-info
        }  // container trap-infos

        container poll-oids {
          description
            "OID list for poll PDU";
          list poll-oid {
            key "object-id";
            description
              "PDU drop info for OID";
            leaf object-id {
              type xr:Cisco-ios-xr-string;
              description "Object ID";
            }

            leaf nms-count {
              type uint32;
              description
                " Managment station count";
            }

            leaf-list nms {
              type Nms-ip;
              max-elements 15;
              description
                "Network Managment station ipadress";
            }

            leaf-list request-count {
              type uint32;
              max-elements 15;
              description
                "OID request count for each Managment station ";
            }
          }  // list poll-oid
        }  // container poll-oids

        container infom-details {
          description "SNMP trap OID";
          list infom-detail {
            description
              "SNMP Trap infomation like server , port and
trapOID";
            leaf trap-host {
              type string;
              description "Trap Host";
            }

            leaf port {
              type inet:port-number;
              description "Trap port";
            }

            leaf host {
              type string;
              description "NMS/Host address";
            }

            leaf port-xr {
              type uint16;
              description "udp port number";
            }

            leaf vrf-name {
              type string;
              description "vrf name";
            }

            leaf time {
              type uint32;
              description
                "Trap delay time Left";
            }

            leaf trap-oid-count {
              type uint32;
              description
                "Total number of OID's sent";
            }

            list trap-oi-dinfo {
              description
                "Per trap OID statistics";
              leaf trap-oid {
                type string;
                description "TRAP OID";
              }

              leaf count {
                type uint32;
                description
                  "Number of traps sent";
              }

              leaf drop-count {
                type uint32;
                description
                  "Number of Traps Dropped at InternalQ";
              }

              leaf drop-host-count {
                type uint32;
                description
                  "Number of Traps Dropped at HostQ";
              }

              leaf drop-delay-timer {
                type uint32;
                description
                  "Number of Traps Dropped due to trap delay timer
expiry";
              }

              leaf retry-count {
                type uint32;
                description
                  "Num of times retry";
              }

              leaf lastsent-time {
                type string;
                description
                  "Timestamp of latest successfully sent";
              }

              leaf lastdrop-time {
                type string;
                description
                  "Timestamp of latest dropped";
              }

              leaf last-hostdrop-time {
                type string;
                description
                  "Timestamp of latest dropped at host";
              }

              leaf last-host-delay-time {
                type string;
                description
                  "Timestamp of latest dropped due to delay timer
expiry";
              }
            }  // list trap-oi-dinfo
          }  // list infom-detail
        }  // container infom-details

        container statistics {
          description "SNMP statistics";
          leaf packets-received {
            type uint32;
            description "snmpInPkts";
          }

          leaf bad-versions-received {
            type uint32;
            description "snmpInBadVersions";
          }

          leaf bad-community-names-received {
            type uint32;
            description
              "snmpInBadCommunityNames";
          }

          leaf bad-community-uses-received {
            type uint32;
            description
              "snmpInBadCommunityUses";
          }

          leaf asn-parse-errors-received {
            type uint32;
            description "snmpInASNParseErrs";
          }

          leaf silent-drop-count {
            type uint32;
            description "snmpSilentDrops";
          }

          leaf proxy-drop-count {
            type uint32;
            description "snmpProxyDrops";
          }

          leaf too-big-packet-received {
            type uint32;
            description "snmpInTooBigs";
          }

          leaf max-packet-size {
            type uint32;
            description
              "snmp maximum packet size";
          }

          leaf no-such-names-received {
            type uint32;
            description "snmpInNoSuchNames";
          }

          leaf bad-values-received {
            type uint32;
            description "snmpInBadValues";
          }

          leaf read-only-received {
            type uint32;
            description "snmpInReadOnlys";
          }

          leaf total-general-errors {
            type uint32;
            description "snmpInGenErrs";
          }

          leaf total-requested-variables {
            type uint32;
            description "snmpInTotalReqVars";
          }

          leaf total-set-variables-received {
            type uint32;
            description "snmpInTotalSetVars";
          }

          leaf get-requests-received {
            type uint32;
            description "snmpInGetRequests";
          }

          leaf get-next-requests-received {
            type uint32;
            description "snmpInGetNexts";
          }

          leaf set-requests-received {
            type uint32;
            description "snmpInSetRequests";
          }

          leaf get-responses-received {
            type uint32;
            description "snmpInGetResponses";
          }

          leaf traps-received {
            type uint32;
            description "snmpInTraps";
          }

          leaf total-packets-sent {
            type uint32;
            description "snmpOutPkts";
          }

          leaf too-big-packets-sent {
            type uint32;
            description "snmpOutTooBigs";
          }

          leaf no-such-names-sent {
            type uint32;
            description "snmpOutNoSuchNames";
          }

          leaf bad-values-sent {
            type uint32;
            description "snmpOutBadValues";
          }

          leaf general-errors-sent {
            type uint32;
            description "snmpOutGenErrs";
          }

          leaf get-requests-sent {
            type uint32;
            description "snmpOutGetRequests";
          }

          leaf get-next-request-sent {
            type uint32;
            description "snmpOutGetNexts";
          }

          leaf set-requests-sent {
            type uint32;
            description "snmpOutSetRequests";
          }

          leaf get-responses-sent {
            type uint32;
            description
              "snmpOutGetResponses";
          }

          leaf traps-sent {
            type uint32;
            description "snmpOutTraps";
          }
        }  // container statistics

        container incoming-queue {
          description
            "Incoming queue details ";
          leaf queue-count {
            type uint32;
            description
              "Number of NMS Queues Exist.";
          }

          list inq-entry {
            max-elements 16;
            description
              "Each Entry Details.";
            leaf address-of-queue {
              type string;
              description "Address of NMS Q";
            }

            leaf request-count {
              type uint32;
              description
                "Request Count of Each Queue.";
            }

            leaf processed-request-count {
              type uint32;
              description
                "Processed request Count.";
            }

            leaf last-access-time {
              type string;
              description
                "Last Access time of Each Queue.";
            }

            leaf priority {
              type uint8;
              description
                "Priority of Each Queue.";
            }
          }  // list inq-entry
        }  // container incoming-queue

        container context-mapping {
          description
            "Context name, features name, topology name,
instance";
          list contex-mapping {
            description "Context Mapping";
            leaf context {
              type string;
              description "Context name";
            }

            leaf feature-name {
              type string;
              description "Feature name";
            }

            leaf instance {
              type string;
              description "Instance name";
            }

            leaf topology {
              type string;
              description "Topology name";
            }

            leaf feature {
              type string;
              description "Feature";
            }
          }  // list contex-mapping
        }  // container context-mapping

        container trap-oids {
          description "SNMP trap OID";
          list trap-oid {
            key "trap-oid";
            description "SNMP trap ";
            leaf trap-oid {
              type xr:Cisco-ios-xr-string;
              description "Trap object ID";
            }

            leaf trap-oid-count {
              type uint32;
              description
                "Total number of OID's sent";
            }

            leaf trap-oid-xr {
              type string;
              description "TRAP OID";
            }
          }  // list trap-oid
        }  // container trap-oids

        container nm-spackets {
          description
            "SNMP overload statistics ";
          list nm-spacket {
            key "packetcount";
            description
              "NMS packet drop count";
            leaf packetcount {
              type xr:Cisco-ios-xr-string;
              description
                "NMS packet drop count";
            }

            leaf number-of-nmsq-pkts-dropped {
              type uint32;
              description
                "Number of packets which are currently enqueued
within the NMS queues";
            }

            leaf number-of-pkts-dropped {
              type uint32;
              description
                "Number of packets dropped";
            }

            leaf overload-start-time {
              type string;
              description
                "Time of overload contol begin";
            }

            leaf overload-end-time {
              type string;
              description
                "Time of overload contol End";
            }
          }  // list nm-spacket
        }  // container nm-spackets

        container mibs {
          description
            "List of MIBS supported on the system";
          list mib {
            key "name";
            description "SNMP MIB Name";
            container oids {
              description
                "List of OIDs per MIB";
              list oid {
                key "oid";
                description
                  "Object identifiers of a mib";
                leaf oid {
                  type string;
                  description
                    "Object Identifier";
                }

                leaf oid-name {
                  type string;
                  mandatory true;
                  description "MIB OID Name";
                }
              }  // list oid
            }  // container oids

            container mib-information {
              description
                "MIB state and information";
              leaf mib-name {
                type string;
                description
                  "Name of the MIB module";
              }

              leaf dll-name {
                type string;
                description
                  "MIB DLL filename, non-DLL MIBs will have no
value";
              }

              leaf mib-config-filename {
                type string;
                description
                  "MIB config filename, non-DLL MIBs will have no
value";
              }

              leaf is-mib-loaded {
                type boolean;
                description
                  "TRUE if MIB DLL is currently loaded, will always
be TRUE for non-DLL MIBs";
              }

              leaf dll-capabilities {
                type uint32;
                description
                  "DLL capabilities";
              }

              leaf trap-strings {
                type string;
                description
                  "List of trapstring configured";
              }

              leaf timeout {
                type boolean;
                description
                  "TRUE is mib is in phase 1 timeout";
              }

              leaf load-time {
                type uint32;
                description "Load time";
              }
            }  // container mib-information

            leaf name {
              type xr:Cisco-ios-xr-string;
              description "MIB Name";
            }
          }  // list mib
        }  // container mibs

        container serial-numbers {
          description "SNMP statistics pdu ";
          list serial-number {
            description "Serial number";
            leaf number {
              type xr:Cisco-ios-xr-string;
              description "Serial number";
            }

            leaf req-id {
              type uint32;
              description "Request ID";
            }

            leaf port {
              type inet:port-number;
              description "Port";
            }

            leaf nms {
              type string;
              description
                " NMS address Rx PDU";
            }

            leaf request-id {
              type uint32;
              description
                " SNMP request id per PDU";
            }

            leaf port-xr {
              type uint16;
              description "NMS port number";
            }

            leaf pdu-type {
              type uint16;
              description " PDU type";
            }

            leaf error-status {
              type uint16;
              description
                "Is reques dropped due to error";
            }

            leaf serial-num {
              type uint32;
              description
                "Serial number per PDU processing";
            }

            leaf input-q {
              type string;
              description
                "Request inserted into input queue";
            }

            leaf output-q {
              type uint32;
              description
                "De-queue the request from the input queue";
            }

            leaf pending-q {
              type uint32;
              description
                "Enqueue the request into pending queue";
            }

            leaf response-out {
              type uint32;
              description "Response sent";
            }
          }  // list serial-number
        }  // container serial-numbers

        container drop-nms-addresses {
          description
            "NMS list for drop PDU";
          list drop-nms-address {
            key "nms-addr";
            description
              "PDU drop info for NMS";
            leaf nms-addr {
              type xr:Cisco-ios-xr-string;
              description "NMS address";
            }

            leaf nms-address {
              type string;
              description
                "NMS address of server";
            }

            leaf incoming-q-count {
              type uint32;
              description
                "Drop Count at Incoming Q";
            }

            leaf threshold-incoming-q-count {
              type uint32;
              description
                "Drop Count at Incoming Q after threshold limit";
            }

            leaf encode-count {
              type uint32;
              description
                "Drop Count with Encode errors";
            }

            leaf duplicate-count {
              type uint32;
              description
                "Duplicate request drop count";
            }

            leaf stack-count {
              type uint32;
              description
                "Drop Count at snmp Stack";
            }

            leaf aipc-count {
              type uint32;
              description
                "drop count with AIPC Buffer Full";
            }

            leaf overload-count {
              type uint32;
              description
                "Drop Count with overload notification";
            }

            leaf timeout-count {
              type uint32;
              description
                "Drop count with timeout";
            }

            leaf internal-count {
              type uint32;
              description
                " drop with Internal Errors";
            }
          }  // list drop-nms-address
        }  // container drop-nms-addresses

        container views {
          description
            "SNMP view information";
          list view {
            key "name";
            description
              "SNMP target view name";
            leaf name {
              type xr:Cisco-ios-xr-string;
              description "View name";
            }

            list view-information {
              key "object-id";
              description
                "View name ,familytype, storagetype and status";
              leaf object-id {
                type xr:Cisco-ios-xr-string;
                description "SNMP view OID";
              }

              leaf snmp-view-family-type {
                type string;
                description
                  "Include or exclude";
              }

              leaf snmp-view-family-storage-type {
                type string;
                description "Storage type";
              }

              leaf snmp-view-family-status {
                type string;
                description
                  "Status of this entry";
              }
            }  // list view-information
          }  // list view
        }  // container views

        container udp-statistics {
          description "SNMP UDP statistics";
          leaf in-event {
            type uint32;
            description "Event";
          }

          leaf in-buferr {
            type uint32;
            description "Buffer Error";
          }

          leaf in-node {
            type uint32;
            description "No Data";
          }

          leaf in-recverr {
            type uint32;
            description "Receive Error";
          }

          leaf in-badarg {
            type uint32;
            description "Invalid Argument";
          }

          leaf in-pkt {
            type uint32;
            description "Packet";
          }

          leaf inm-badarg {
            type uint32;
            description "Invalid Argument";
          }

          leaf inm-pac-conn {
            type uint32;
            description
              "Packet connection error";
          }

          leaf inm-pak-nodata {
            type uint32;
            description "Packet no data";
          }

          leaf inm-pak-recerr {
            type uint32;
            description
              "Packet receive error";
          }

          leaf inm-pak-null {
            type uint32;
            description "Packet Null";
          }

          leaf inm-pak-vrfid {
            type uint32;
            description "Packet VRF error";
          }

          leaf inm-pak-tblid {
            type uint32;
            description "Packet table error";
          }

          leaf inm-pak-ifinput {
            type uint32;
            description
              "Packet ifinput error";
          }

          leaf inm-pak-offnet {
            type uint32;
            description
              "Packet network Offset error";
          }

          leaf inm-pak-readnet {
            type uint32;
            description
              "Packet network read error";
          }

          leaf inm-pak-offtrans {
            type uint32;
            description
              "Packet transport offset error";
          }

          leaf inm-pak-readtrans {
            type uint32;
            description
              "Packet read transport error ";
          }

          leaf inm-pak-offapp {
            type uint32;
            description
              "Packet application offset error";
          }

          leaf inm-pak-readapp {
            type uint32;
            description
              "Packet application read error";
          }

          leaf inm-pak-trunc {
            type uint32;
            description "Packet Truncated";
          }

          leaf out-toobig {
            type uint32;
            description "Too Big";
          }

          leaf out-pkt {
            type uint32;
            description "Packet";
          }

          leaf out-senderr {
            type uint32;
            description "Send Error";
          }

          leaf outm-badarg {
            type uint32;
            description "Invalid argument";
          }

          leaf outm-pak-buf {
            type uint32;
            description
              "Packet Buffer Error";
          }

          leaf outm-pak-vrfid {
            type uint32;
            description "Packet VRF Error";
          }

          leaf outm-pak-tblid {
            type uint32;
            description "Packet table error";
          }

          leaf outm-pak-write {
            type uint32;
            description "Packet write error";
          }

          leaf outm-pak-trunc {
            type uint32;
            description
              "Packet connection Error";
          }

          leaf outm-pak-conn {
            type uint32;
            description "Packet Send Error";
          }
        }  // container udp-statistics

        container system-descr {
          description "System description";
          leaf sys-descr {
            type string;
            description
              "sysDescr  1.3.6.1.2.1.1.1";
          }
        }  // container system-descr

        container tables {
          description "List of table";
          container groups {
            description
              "List of vacmAccessTable";
            list group {
              key "name";
              description "SNMP group name";
              container group-informations {
                description "Group Model";
                list group-information {
                  description
                    "Group name ,status  and information";
                  leaf modelnumber {
                    type xr:Cisco-ios-xr-string;
                    description
                      "Model number";
                  }

                  leaf level {
                    type xr:Cisco-ios-xr-string;
                    description "Level";
                  }

                  leaf vacm-access-read-view-name {
                    type string;
                    description
                      "Read view name";
                  }

                  leaf vacm-access-write-view-name {
                    type string;
                    description
                      "Write view name";
                  }

                  leaf vacm-access-notify-view-name {
                    type string;
                    description
                      "Notify view name";
                  }

                  leaf vacm-access-status {
                    type uint32;
                    description
                      "Status of this view configuration";
                  }
                }  // list group-information
              }  // container group-informations

              leaf name {
                type xr:Cisco-ios-xr-string;
                description "Group Name";
              }
            }  // list group
          }  // container groups

          container user-engine-ids {
            description "List of User";
            list user-engine-id {
              key "engine-id";
              description "SNMP engineId";
              leaf engine-id {
                type xr:Cisco-ios-xr-string;
                description "SNMP Engine ID";
              }

              list user-name {
                key "user-name";
                description
                  "User name ,storage type ,status ";
                leaf user-name {
                  type xr:Cisco-ios-xr-string;
                  description "User name";
                }

                leaf usm-user-storage-type {
                  type uint32;
                  description "Storage type";
                }

                leaf usm-user-status {
                  type uint32;
                  description
                    "Status of this user";
                }
              }  // list user-name
            }  // list user-engine-id
          }  // container user-engine-ids
        }  // container tables

        container system-oid {
          description "System object ID";
          leaf sys-obj-id {
            type string;
            description
              "sysObjID  1.3.6.1.2.1.1.2";
          }
        }  // container system-oid

        container trap-queue {
          description
            "SNMP trap queue statistics";
          leaf trap-min {
            type uint32;
            description "trap min";
          }

          leaf trap-avg {
            type uint32;
            description "trap avg";
          }

          leaf trap-max {
            type uint32;
            description "trap max";
          }

          list trap-q {
            max-elements 300;
            description "trap q";
            leaf min {
              type uint32;
              description "min";
            }

            leaf avg {
              type uint32;
              description "avg";
            }

            leaf max {
              type uint32;
              description "max";
            }
          }  // list trap-q
        }  // container trap-queue
      }  // container information

      container interfaces {
        description "List of interfaces";
        list interface {
          key "name";
          description "Interface Name";
          leaf name {
            type xr:Interface-name;
            description "Interface Name";
          }

          leaf interface-index {
            type uint32;
            mandatory true;
            description
              "Interface Index as used by MIB tables";
          }
        }  // list interface
      }  // container interfaces

      container correlator {
        description
          "Trap Correlator operational data";
        container rule-details {
          description
            "Table that contains the database of correlation
rule details";
          list rule-detail {
            key "rule-name";
            description
              "Details of one of the correlation rules";
            leaf rule-name {
              type string {
                length "1..32";
              }
              description
                "Correlation Rule Name";
            }

            container rule-summary {
              description
                "Rule summary, name, etc";
              leaf rule-name {
                type string;
                description
                  "Correlation Rule Name";
              }

              leaf rule-state {
                type Snmp-corr-rule-state;
                description
                  "Applied state of the rule It could be not
applied, applied or applied to all";
              }

              leaf buffered-traps-count {
                type uint32;
                description
                  "Number of buffered traps correlated to this rule";
              }
            }  // container rule-summary

            container root-cause {
              description
                "OID/VarBinds defining the rootcause match
conditions.";
              leaf oid {
                type string;
                description
                  "OID of the trap";
              }

              list var-bind {
                description
                  "VarBinds of the trap";
                leaf oid {
                  type string;
                  description
                    "OID of the varbind";
                }

                leaf match-type {
                  type Snmp-corr-vbind-match;
                  description
                    "Varbind match type";
                }

                leaf reg-exp {
                  type string;
                  description
                    "Regular expression to match";
                }
              }  // list var-bind
            }  // container root-cause

            leaf timeout {
              type uint32;
              description
                "Time window (in ms) for which root/all messages
are kept in correlater before sending them to
hosts";
            }

            list non-root-cause {
              description
                "OIDs/VarBinds defining the nonrootcause match
conditions.";
              leaf oid {
                type string;
                description
                  "OID of the trap";
              }

              list var-bind {
                description
                  "VarBinds of the trap";
                leaf oid {
                  type string;
                  description
                    "OID of the varbind";
                }

                leaf match-type {
                  type Snmp-corr-vbind-match;
                  description
                    "Varbind match type";
                }

                leaf reg-exp {
                  type string;
                  description
                    "Regular expression to match";
                }
              }  // list var-bind
            }  // list non-root-cause

            list apply-host {
              description
                "Hosts (IP/port) to which the rule is applied";
              leaf ip-address {
                type string;
                description
                  "IP address of the host";
              }

              leaf port {
                type uint16;
                description
                  "Port of the host";
              }
            }  // list apply-host
          }  // list rule-detail
        }  // container rule-details

        container buffer-status {
          description
            "Describes buffer utilization and parameters
configured";
          leaf current-size {
            type uint32;
            description
              "Current buffer usage";
          }

          leaf configured-size {
            type uint32;
            description
              "Configured buffer size";
          }
        }  // container buffer-status

        container rule-set-details {
          description
            "Table that contains the ruleset detail info";
          list rule-set-detail {
            key "rule-set-name";
            description
              "Detail of one of the correlation rulesets";
            leaf rule-set-name {
              type string {
                length "1..32";
              }
              description "Ruleset Name";
            }

            leaf rule-set-name-xr {
              type string;
              description "Ruleset Name";
            }

            list rules {
              description
                "Rules contained in a ruleset";
              leaf rule-name {
                type string;
                description
                  "Correlation Rule Name";
              }

              leaf rule-state {
                type Snmp-corr-rule-state;
                description
                  "Applied state of the rule It could be not
applied, applied or applied to all";
              }

              leaf buffered-traps-count {
                type uint32;
                description
                  "Number of buffered traps correlated to this rule";
              }
            }  // list rules
          }  // list rule-set-detail
        }  // container rule-set-details

        container traps {
          description
            "Correlated traps Table";
          list trap {
            key "entry-id";
            description
              "One of the correlated traps";
            leaf entry-id {
              type uint32;
              description "Entry ID";
            }

            container trap-info {
              description
                "Correlated trap information";
              leaf oid {
                type string;
                description "Object ID";
              }

              leaf relative-timestamp {
                type uint32;
                units "second";
                description
                  "Number of hsecs elapsed since snmpd was started";
              }

              leaf timestamp {
                type uint64;
                units "millisecond";
                description
                  "Time when the trap was generated. It is
expressed in number of milliseconds since 00:00
:00 UTC, January 1, 1970";
              }

              list var-bind {
                description
                  "VarBinds on the trap";
                leaf oid {
                  type string;
                  description
                    "OID of the varbind";
                }

                leaf value {
                  type string;
                  description
                    "Value of the varbind";
                }
              }  // list var-bind
            }  // container trap-info

            leaf correlation-id {
              type uint32;
              description "Correlation ID";
            }

            leaf is-root-cause {
              type boolean;
              description
                "True if this is the rootcause";
            }

            leaf rule-name {
              type string;
              description
                "Correlation rule name";
            }
          }  // list trap
        }  // container traps
      }  // container correlator

      container interface-indexes {
        description "List of index";
        list interface-index {
          key "interface-index";
          description "Interface Index";
          leaf interface-index {
            type uint32;
            description
              "Interface Index as used by MIB tables";
          }

          leaf interface-name {
            type string;
            mandatory true;
            description "Interface Name";
          }
        }  // list interface-index
      }  // container interface-indexes

      container if-indexes {
        description "List of ifnames";
        list if-index {
          key "interface-index";
          description "Interface Index";
          leaf interface-index {
            type uint32;
            description
              "Interface Index as used by MIB tables";
          }

          leaf interface-name {
            type string;
            description "Interface Name";
          }
        }  // list if-index
      }  // container if-indexes

      container entity-mib {
        description "SNMP entity mib";
        container entity-physical-indexes {
          description "SNMP entity mib";
          list entity-physical-index {
            key "entity-phynum";
            description
              "SNMP entPhysical index number";
            leaf entity-phynum {
              type xr:Cisco-ios-xr-string;
              description
                "Entity physical index";
            }

            leaf physical-index {
              type uint32;
              description "entPhysicalIndex";
            }

            leaf ent-physical-name {
              type string;
              description "entPhysicalName";
            }

            leaf location {
              type string;
              description "invmgr EDM path";
            }

            leaf ent-physical-descr {
              type string;
              description
                "EntPhysicalDescription";
            }

            leaf ent-physical-firmware-rev {
              type string;
              description
                "entphysicalFirmwareRev";
            }

            leaf ent-physical-hardware-rev {
              type string;
              description
                "entphysicalHardwareRev";
            }

            leaf ent-physical-modelname {
              type string;
              description
                "entphysicalModelName";
            }

            leaf ent-physical-serial-num {
              type string;
              description
                "entphysicalSerialNum";
            }

            leaf ent-physical-software-rev {
              type string;
              description
                "entphysicalSoftwareRev";
            }

            leaf ent-physical-mfg-name {
              type string;
              description
                "entphysicalMfgName";
            }
          }  // list entity-physical-index
        }  // container entity-physical-indexes
      }  // container entity-mib

      container interface-mib {
        description
          "SNMP IF-MIB information";
        container interfaces {
          description
            "Interfaces ifIndex information";
          list interface {
            key "interface-name";
            description
              "ifIndex for a specific Interface Name";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface Name";
            }

            leaf if-index {
              type uint32;
              description "Interface Index";
            }
          }  // list interface
        }  // container interfaces

        container interface-connectors {
          description
            "Interfaces ifConnectorPresent information";
          list interface-connector {
            key "interface-name";
            description
              "ifConnectorPresent for a specific Interface
Name";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface Name";
            }

            leaf if-connector-present {
              type string;
              description
                "Interface ifConnector";
            }
          }  // list interface-connector
        }  // container interface-connectors

        container interface-aliases {
          description
            "Interfaces ifAlias information";
          list interface-alias {
            key "interface-name";
            description
              "ifAlias for a specific Interface Name";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface Name";
            }

            leaf if-alias {
              type string;
              description
                "Interface ifAlias";
            }
          }  // list interface-alias
        }  // container interface-aliases

        container notification-interfaces {
          description
            "Interfaces Notification information";
          list notification-interface {
            key "interface-name";
            description
              "Notification for specific Interface Name";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface Name";
            }

            leaf link-up-down-notif-status {
              type Link-up-down-status;
              description
                "LinkUpDown notification status";
            }
          }  // list notification-interface
        }  // container notification-interfaces

        container interface-stack-statuses {
          description
            "Interfaces ifstackstatus information";
          list interface-stack-status {
            key "interface-stack-status";
            description
              "ifstatus for a pair of Interface";
            leaf interface-stack-status {
              type xr:Cisco-ios-xr-string;
              description
                "StackHigherLayer.StackLowerLayer";
            }

            leaf if-stack-higher-layer {
              type string;
              description
                "Higher Layer Index";
            }

            leaf if-stack-lower-layer {
              type string;
              description
                "Lowyer Layer Index";
            }

            leaf if-stack-status {
              type string;
              description
                "Interface ifStackStaus info";
            }
          }  // list interface-stack-status
        }  // container interface-stack-statuses
      }  // container interface-mib

      container sensor-mib {
        description
          "SNMP sensor MIB information";
        container physical-indexes {
          description
            "List of physical index table for threshold
value";
          list physical-index {
            key "index";
            description
              "Threshold value for physical index";
            container threshold-indexes {
              description
                "List of threshold index";
              list threshold-index {
                description
                  "Threshold value for threshold index";
                leaf phy-index {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Physical Index";
                }

                leaf thre-index {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Threshold index";
                }

                leaf threshold-severity {
                  type uint32;
                  description
                    "Indicates minor, major, critical severities";
                }

                leaf threshold-relation {
                  type uint32;
                  description
                    "Indicates relation between sensor value and
threshold";
                }

                leaf threshold-value {
                  type int32;
                  description
                    "Value of the configured threshold";
                }

                leaf threshold-evaluation {
                  type boolean;
                  description
                    "Indicates the result of the most recent
evaluation of the thresholD";
                }

                leaf threshold-notification-enabled {
                  type boolean;
                  description
                    "Indicates whether or not a notification should
result, in case of threshold violation";
                }
              }  // list threshold-index
            }  // container threshold-indexes

            leaf index {
              type xr:Cisco-ios-xr-string;
              description "Physical index";
            }
          }  // list physical-index
        }  // container physical-indexes

        container ent-phy-indexes {
          description
            "List of physical index ";
          list ent-phy-index {
            key "index";
            description
              "Sensor value for physical index";
            leaf index {
              type xr:Cisco-ios-xr-string;
              description "Physical index";
            }

            leaf field-validity-bitmap {
              type uint32;
              description
                "Sensor valid bitmap";
            }

            leaf device-description {
              type string {
                length "0..64";
              }
              description "Device Name";
            }

            leaf units {
              type string {
                length "0..64";
              }
              description
                "Units of variable being read";
            }

            leaf device-id {
              type uint32;
              description
                "Identifier for this device";
            }

            leaf value {
              type uint32;
              description
                "Current reading of sensor";
            }

            leaf alarm-type {
              type uint32;
              description
                "Indicates threshold violation";
            }

            leaf data-type {
              type uint32;
              description
                "Sensor data type enums";
            }

            leaf scale {
              type uint32;
              description
                "Sensor scale enums";
            }

            leaf precision {
              type uint32;
              description
                "Sensor precision range";
            }

            leaf status {
              type uint32;
              description
                "Sensor operation state enums";
            }

            leaf age-time-stamp {
              type uint32;
              description
                "Age of the sensor value; set to the current time
if directly access the value from sensor";
            }

            leaf update-rate {
              type uint32;
              description
                "Sensor value update rate;set to 0 if sensor
value is updated and evaluated immediately";
            }

            leaf measured-entity {
              type uint32;
              description
                "physical entity for which the sensor is taking
measurements";
            }
          }  // list ent-phy-index
        }  // container ent-phy-indexes
      }  // container sensor-mib
    }  // container snmp
  }  // module Cisco-IOS-XR-snmp-agent-oper