submodule Cisco-IOS-XR-msdp-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-msdp-oper {
        prefix Cisco-IOS-XR-msdp-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

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

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

    revision "2019-08-27" {
      description
        "Providing MSDP information.";
    }

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

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

    semver:module-version "1.0.0";

    typedef Msdp-rpf-rule {
      type enumeration {
        enum "msdp-rpf-rule-failed" {
          value 0;
          description "msdp rpf rule failed";
        }
        enum "msdp-rpf-rule-rp" {
          value 1;
          description "msdp rpf rule rp";
        }
        enum "msdp-rpf-rule-ebgp" {
          value 2;
          description "msdp rpf rule ebgp";
        }
        enum "msdp-rpf-rule-next-hop" {
          value 3;
          description
            "msdp rpf rule next hop";
        }
        enum "msdp-rpf-rule-as-path" {
          value 4;
          description
            "msdp rpf rule as path";
        }
        enum "msdp-rpf-rule-static" {
          value 5;
          description "msdp rpf rule static";
        }
        enum "msdp-rpf-rule-local" {
          value 6;
          description "msdp rpf rule local";
        }
        enum "msdp-rpf-rule-one-peer" {
          value 7;
          description
            "msdp rpf rule one peer";
        }
        enum "msdp-rpf-rule-mesh-grp" {
          value 8;
          description
            "msdp rpf rule mesh grp";
        }
        enum "msdp-rpf-rule-default-tree" {
          value 9;
          description
            "msdp rpf rule default tree";
        }
        enum "msdp-rpf-rule-max" {
          value 10;
          description "msdp rpf rule max";
        }
      }
      description "Msdp rpf rule";
    }

    typedef Msdp-session-sso-state {
      type enumeration {
        enum
          "msdp-session-sso-state-unknown" {
          value 0;
          description
            "msdp session sso state unknown";
        }
        enum
          "msdp-session-sso-state-tcp-down" {
          value 1;
          description
            "msdp session sso state tcp down";
        }
        enum
          "msdp-session-sso-state-tcp-synced" {
          value 2;
          description
            "msdp session sso state tcp synced";
        }
        enum
          "msdp-session-sso-state-msdp-synced" {
          value 3;
          description
            "msdp session sso state msdp synced";
        }
        enum
          "msdp-session-sso-state-msdp-synced-hold" {
          value 4;
          description
            "msdp session sso state msdp synced hold";
        }
        enum
          "msdp-session-sso-state-tcp-stop-read" {
          value 5;
          description
            "msdp session sso state tcp stop read";
        }
        enum
          "msdp-session-sso-state-tcp-replicated" {
          value 6;
          description
            "msdp session sso state tcp replicated";
        }
        enum
          "msdp-session-sso-state-nsr-ready" {
          value 7;
          description
            "msdp session sso state nsr ready";
        }
        enum "msdp-session-sso-state-max" {
          value 8;
          description
            "msdp session sso state max";
        }
      }
      description "Msdp session sso state";
    }

    typedef Msdp-peer-state {
      type enumeration {
        enum "msdp-null-state" {
          value 0;
          description "msdp null state";
        }
        enum "msdp-disabled" {
          value 1;
          description "msdp disabled";
        }
        enum "msdp-inactive" {
          value 2;
          description "msdp inactive";
        }
        enum "msdp-listening" {
          value 3;
          description "msdp listening";
        }
        enum "msdp-connecting" {
          value 4;
          description "msdp connecting";
        }
        enum "msdp-established" {
          value 5;
          description "msdp established";
        }
        enum "msdp-no-interface" {
          value 6;
          description "msdp no interface";
        }
        enum "msdp-intf-no-addr" {
          value 7;
          description "msdp intf no addr";
        }
        enum "msdp-same-addr" {
          value 8;
          description "msdp same addr";
        }
        enum "msdp-peer-stop" {
          value 9;
          description "msdp peer stop";
        }
        enum "msdp-tcp-synced" {
          value 10;
          description "msdp tcp synced";
        }
        enum "msdp-max-state" {
          value 11;
          description "msdp max state";
        }
      }
      description "Msdp peer state";
    }

    grouping MSDP-NSR-BAG {
      description "NSR Related information";
      leaf state {
        type uint8;
        description "NSR state";
      }

      leaf rmf-notification-done {
        type boolean;
        description "RMF Notification done";
      }

      leaf rmf-timer-valid {
        type boolean;
        description "Is RMF timer running ?";
      }

      leaf rmf-timer-expiry {
        type uint64;
        description
          "Time for RMF timer to expire";
      }

      leaf last-rmf-ready {
        type uint64;
        description
          "Time when RMF Rdy notif was sent";
      }

      leaf last-rmf-not-ready {
        type uint64;
        description
          "Time when RMF Not-Rdy notif was sent";
      }

      leaf count-rmf-ready {
        type uint32;
        description
          "No. of times RMF Ready notif was sent";
      }

      leaf count-rmf-not-ready {
        type uint32;
        description
          "No. of times RMF Not Ready notif was sent";
      }

      leaf nsr-force-timer-left {
        type uint64;
        units "second";
        description
          "NSR Force Timer left in seconds";
      }
    }  // grouping MSDP-NSR-BAG

    grouping MSDP-PROCESS-SUMM-BAG {
      description "MSDP Peer Summary Global";
      leaf is-maximum-disable {
        type boolean;
        description
          "Is maximum enforcement disabled";
      }

      leaf global-maximum-sa {
        type uint32;
        description "Global OOR Limit";
      }

      leaf external-active-sa {
        type uint32;
        description
          "Current Active Ext. SAs";
      }

      leaf is-node-low-memory {
        type boolean;
        description
          "Is node in low memory condition";
      }
    }  // grouping MSDP-PROCESS-SUMM-BAG

    grouping MSDP-EDM-NSF-BAG {
      description "MSDP NSF state";
      leaf is-multicast-nsf-active {
        type boolean;
        description
          "Is Multicast NSF active";
      }

      leaf multicast-nsf-timeout {
        type uint64;
        description "MSDP NSF period in sec";
      }

      leaf multicast-nsf-time-left {
        type uint64;
        description
          "MSDP NSF expiry time in sec";
      }

      leaf last-nsf-on {
        type int64;
        description
          "Time when MSDP went NSF";
      }

      leaf last-nsf-off {
        type int64;
        description
          "Time when MSDP came out of NSF";
      }

      leaf last-nsf-on-sec {
        type int64;
        description
          "Time in sec since last NSF on event";
      }

      leaf last-nsf-off-sec {
        type int64;
        description
          "Time in sec since last NSF off event";
      }

      leaf last-icd-notif-recv {
        type int64;
        description
          "Time when last ICD Notif Rcvd";
      }

      leaf last-icd-notif-recvsec {
        type int64;
        description
          "Time in sec since last ICD Notif";
      }
    }  // grouping MSDP-EDM-NSF-BAG

    grouping MSDP-RP-BAG {
      description "MSDP RP Sources";
      list msdp-rp-bag {
        description "Point to the next one";
        leaf rp-address {
          type inet:ipv4-address;
          description "The RP Address";
        }

        leaf rp-prefix {
          type inet:ipv4-address;
          description
            "Prefix used for this RP";
        }

        leaf rp-prefix-length {
          type int32;
          description
            "Prefix length used for this RP";
        }

        leaf advertizing-peer {
          type inet:ipv4-address;
          description "The Advertizing Peer";
        }

        leaf rpf-peer {
          type inet:ipv4-address;
          description "The RPF Peer";
        }

        leaf rp-source-count {
          type uint32;
          description "Total source count";
        }

        leaf rp-sources-active {
          type uint32;
          description "Active source count";
        }

        leaf heard {
          type uint32;
          units "second";
          description
            "Last Heard From (seconds)";
        }
      }  // list msdp-rp-bag
    }  // grouping MSDP-RP-BAG

    grouping MSDP-GLOBAL-BAG {
      description "Global MSDP state";
      container rp-information {
        description "RP information";
        uses MSDP-RP-BAG;
      }  // container rp-information

      leaf process-id {
        type uint32;
        description
          "MSDP Process ID, 0 if disabled";
      }

      leaf local-as-number-string {
        type string;
        description
          "AS number we operate within";
      }

      leaf caching {
        type int32;
        description "Is SA caching enabled";
      }

      leaf default-peer {
        type inet:ipv4-address;
        description
          "The default peer address";
      }

      leaf is-pim-connected {
        type boolean;
        description
          "Is MSDP registered with PIM for Registers";
      }

      leaf originator-id {
        type inet:ipv4-address;
        description "Originator ID";
      }

      leaf active-sources {
        type uint32;
        description "Total Active Sources";
      }

      leaf active-groups {
        type uint32;
        description "Total Active Groups";
      }

      leaf active-rp {
        type uint32;
        description
          "Number of active RPs (local and remote)";
      }

      leaf external-sa {
        type uint32;
        description
          "Number of externally learns SA states";
      }

      leaf items-allocated {
        type uint64;
        description
          "Current List Items Allocated";
      }

      leaf lists-allocated {
        type uint64;
        description
          "Current Lists Allocated";
      }

      leaf items-free {
        type uint64;
        description "Total List Items freed";
      }

      leaf lists-free {
        type uint64;
        description "Total Lists freed";
      }

      leaf sa-buffers-allocated {
        type uint32;
        description
          "Total SA buffers allocated";
      }

      leaf sa-buffers-free {
        type uint32;
        description "Total SA buffers free";
      }

      leaf source-buffers-allocated {
        type uint32;
        description
          "Total SA Source buffers allocated";
      }

      leaf source-buffers-free {
        type uint32;
        description
          "Total SA Sourcebuffers free";
      }

      leaf group-buffers-allocated {
        type uint32;
        description
          "Total SA Group buffers allocated";
      }

      leaf group-buffers-free {
        type uint32;
        description
          "Total SA Group buffers free";
      }

      leaf rp-buffers-allocated {
        type uint32;
        description
          "Total SA RP buffers allocated";
      }

      leaf rp-buffers-free {
        type uint32;
        description
          "Total SA RP buffers free";
      }

      leaf maximum-sources {
        type uint32;
        description "Maximum Sources Seen";
      }

      leaf maximum-groups {
        type uint32;
        description "Maximum Groups Seen";
      }

      leaf maximum-rp-sources {
        type uint32;
        description "Maximum RPs Seen";
      }

      leaf maximum-external-sa {
        type uint32;
        description
          "Maximum external SA seen";
      }
    }  // grouping MSDP-GLOBAL-BAG

    grouping MSDP-SUMMARY-AS-BAG {
      description "MSDP Summary AS Bag";
      leaf as-number-string {
        type string;
        description "Peer's ASnum";
      }

      leaf sa-total {
        type uint32;
        description "SA count ";
      }

      leaf number-of-rp {
        type uint32;
        description "Number of RPs";
      }
    }  // grouping MSDP-SUMMARY-AS-BAG

    grouping MSDP-SUMMARY-PREFACE-BAG {
      description "MSDP Summary Preface Bag";
      leaf sa-count {
        type uint32;
        description "Active SA count";
      }

      leaf rp-count {
        type uint32;
        description "RP count ";
      }

      leaf source-count {
        type uint32;
        description "Source count ";
      }

      leaf group-count {
        type uint32;
        description "Group count ";
      }
    }  // grouping MSDP-SUMMARY-PREFACE-BAG

    grouping MSDP-SUMMARY-RP-BAG {
      description "MSDP Summary RP Bag";
      leaf rp-address-xr {
        type inet:ipv4-address;
        description "Originator RP address";
      }

      leaf rp-prefix {
        type inet:ipv4-address;
        description
          "Prefix used for this RP";
      }

      leaf rp-prefix-length {
        type int32;
        description
          "Prefix length used for this RP";
      }

      leaf sa-total {
        type uint32;
        description "SA count ";
      }

      leaf rpf-peer {
        type inet:ipv4-address;
        description "The RPF Peer";
      }
    }  // grouping MSDP-SUMMARY-RP-BAG

    grouping MSDP-CONTEXT {
      description "MSDP Context bag";
      leaf context-name {
        type string;
        description "Name of context";
      }

      leaf context-id {
        type uint32;
        description "Context identifier";
      }

      leaf table-id {
        type uint32;
        description
          "Active table identifier";
      }

      leaf table-count {
        type uint32;
        description "Count of tables";
      }

      leaf active-table-count {
        type uint32;
        description "Count of active tables";
      }

      leaf inheritable-ttl {
        type uint32;
        description
          "TTL inheritable by peers";
      }

      leaf inheritable-max-sa {
        type uint32;
        description
          "Maximum SAs inheritable by peers";
      }

      leaf inheritable-keepalive-period {
        type uint32;
        description
          "Keepalive period inheritable by peers";
      }

      leaf inheritable-peer-timeout-period {
        type uint32;
        description
          "Peer timeout period inheritable by peers";
      }

      leaf inheritable-connect-source {
        type string;
        description
          "Connect source interface inheritable by peers";
      }

      leaf inheritable-sa-filter-in {
        type string;
        description
          "SA filter in inheritable by peers";
      }

      leaf inheritable-sa-filter-out {
        type string;
        description
          "SA filter out inheritable by peers";
      }

      leaf inheritable-rp-filter-in {
        type string;
        description
          "RP filter in inheritable by peers";
      }

      leaf inheritable-rp-filter-out {
        type string;
        description
          "RP filter out inheritable by peers";
      }

      leaf originator-address {
        type inet:ipv4-address;
        description "Originator address";
      }

      leaf originator-interface-name {
        type string;
        description
          "Originator interface name";
      }

      leaf default-peer-address {
        type inet:ipv4-address;
        description "Default peer address";
      }

      leaf sa-holdtime {
        type uint32;
        description "SA holdtime";
      }

      leaf allow-encaps-count {
        type uint32;
        description
          "Count of allowed encaps";
      }

      leaf context-sa-maximum {
        type uint32;
        description
          "Maximum SA in the context";
      }

      leaf as-number {
        type uint32;
        description "Local AS Number";
      }

      leaf peer-count {
        type uint32;
        description "Count of peers";
      }

      leaf estasblished-peer-count {
        type uint32;
        description
          "Count of peers in established state";
      }

      leaf group-count {
        type uint32;
        description
          "Count of groups present";
      }

      leaf source-count {
        type uint32;
        description
          "Count of sources present";
      }

      leaf rp-count {
        type uint32;
        description "Count of RPs present";
      }

      leaf external-source-count {
        type uint32;
        description
          "Count of external sources present";
      }

      leaf group-count-hwm {
        type uint32;
        description
          "High water mark of group count";
      }

      leaf source-count-hwm {
        type uint32;
        description
          "High water mark of source count";
      }

      leaf rp-count-hwm {
        type uint32;
        description
          "High water mark of RP count";
      }

      leaf external-source-hwm {
        type uint32;
        description
          "High water mark of external sources count";
      }

      leaf mrib-update-count {
        type uint32;
        description "Count of MRIB Updates";
      }

      leaf mrib-update-no-change-count {
        type uint32;
        description
          "Count of MRIB updates with no change";
      }

      leaf mrib-update-group {
        type uint32;
        description
          "Count of MRIB update for *,G routes";
      }

      leaf mrib-update-source {
        type uint32;
        description
          "Count of MRIB updates for S,G routes";
      }

      leaf mrib-update-drop-invalid-group {
        type uint32;
        description
          "Count of MRIB updates dropped for an invalid
         group address";
      }

      leaf mrib-update-drop-invalid-group-length {
        type uint32;
        description
          "Count of MRIB updates dropped for an invalid
         group length";
      }

      leaf mribu-pdate-drop-invalid-source {
        type uint32;
        description
          "Count of MRIB updates dropped for an invalid
         source address";
      }

      leaf mrib-update-group-auto-rp {
        type uint32;
        description
          "Count of MRIB updates dropped for AutoRP address";
      }

      leaf pim-suppress-shared-tree-join {
        type boolean;
        description
          "Suppress shared tree join configured";
      }
    }  // grouping MSDP-CONTEXT

    grouping MSDP-RPF-BAG {
      description "MSDP RPF Info";
      leaf local-as-number-string {
        type string;
        description "Local AS Number";
      }

      leaf matching-rule {
        type Msdp-rpf-rule;
        description "Matching Rule";
      }

      leaf peer-address {
        type inet:ipv4-address;
        description "RPF peer";
      }

      leaf peer-as-number-string {
        type string;
        description "Peers AS Number";
      }

      leaf bgp-nexthop {
        type inet:ipv4-address;
        description "BGP Nexthop";
      }

      leaf as-number-string {
        type string;
        description "Nexthop AS Number";
      }

      leaf matching-prefix {
        type inet:ipv4-address;
        description "Matching Prefix";
      }

      leaf prefix-length {
        type uint32;
        description "Prefix Length";
      }

      leaf as-path {
        type yang:hex-string;
        description "The AS Path";
      }
    }  // grouping MSDP-RPF-BAG

    grouping MSDP-SRC-BAG {
      description
        "MSDP active source cache entry";
      leaf source-address-xr {
        type inet:ipv4-address;
        description "Source address";
      }

      leaf source-prefix-length {
        type uint32;
        description "Prefix length";
      }

      leaf source-flag {
        type uint32;
        description "Source specific flags";
      }

      leaf group-address-xr {
        type inet:ipv4-address;
        description "Group address";
      }

      leaf group-prefix-length {
        type uint32;
        description "Group Prefix length";
      }

      leaf group-flag {
        type uint32;
        description "Source specific flags";
      }

      leaf rp-address-xr {
        type inet:ipv4-address;
        description
          "RP address that orginated this source";
      }

      leaf rpf-peer {
        type inet:ipv4-address;
        description
          "The peer we accepted this SA from";
      }

      leaf rpf-as-number-string {
        type string;
        description
          "The AS of the peer that advertised this";
      }

      leaf advertizing-peer {
        type inet:ipv4-address;
        description
          "The peer we should have";
      }

      leaf advertizing-peer-as-string {
        type string;
        description
          "The AS of the peer that advertised this";
      }

      leaf matching-rule {
        type Msdp-rpf-rule;
        description
          "The RPF rule used to select this SA";
      }

      leaf sa-received-count {
        type uint32;
        description
          "The number of SA messages recv'd";
      }

      leaf encapsulated-data-bytes {
        type uint32;
        units "byte";
        description
          "The bytes of encapsulated data recv'd";
      }

      leaf encapsulated-data-packets {
        type uint32;
        description
          "No. of encapsulated data pkts recv'd";
      }

      leaf created {
        type uint64;
        description "Time entry was created";
      }

      leaf expires {
        type uint64;
        description "When the entry expires";
      }
    }  // grouping MSDP-SRC-BAG

    grouping MSDP-PEER-TIMER-BAG {
      description "MSDP Peer Timer Values";
      leaf connect-retry-interval {
        type uint32;
        description "Connect Retry Interval";
      }

      leaf holdtime {
        type uint32;
        description "SA Holdtime";
      }

      leaf keep-alive-interval {
        type uint32;
        description "Keepalive Interval";
      }
    }  // grouping MSDP-PEER-TIMER-BAG

    grouping MSDP-PEER-SUMM-BAG {
      description "MSDP Peer State";
      leaf peer-address-xr {
        type inet:ipv4-address;
        description "Peer Address";
      }

      leaf as-number-string {
        type string;
        description "Peers AS number";
      }

      leaf peer-flag {
        type uint32;
        description "Peer flags";
      }

      leaf peer-state {
        type Msdp-peer-state;
        description "Peer state";
      }

      leaf description {
        type string;
        description "Description";
      }

      leaf started {
        type uint64;
        units "second";
        description
          "Time in current state (seconds)";
      }

      leaf reset {
        type uint32;
        description
          "Number of times peers has reset";
      }

      leaf connect-attempt {
        type uint32;
        description
          "Number of connect attempts";
      }

      leaf establish-transition {
        type uint32;
        description
          "No. of transitions to ESTB state";
      }

      leaf tlv-sent {
        type uint32;
        description "TLV Sent";
      }

      leaf tlv-received {
        type uint32;
        description "TLV Received";
      }

      leaf active-sa-count {
        type uint32;
        description "Active SA Count";
      }

      leaf max-sa {
        type uint32;
        description "Peer Max SA";
      }

      leaf peer-sso-state {
        type Msdp-session-sso-state;
        description "Peer SSO state";
      }

      leaf oper-downs {
        type uint32;
        description
          "Number of TCP SSO oper-downs";
      }

      leaf sso-started {
        type uint32;
        units "second";
        description
          "Time in current state (seconds)";
      }
    }  // grouping MSDP-PEER-SUMM-BAG

    grouping MSDP-PEER-BAG {
      description "MSDP Peer State";
      container peer-sumary-info {
        description "Basic peer Information";
        uses MSDP-PEER-SUMM-BAG;
      }  // container peer-sumary-info

      container peer-timer-values {
        description
          "Peer specific timer values";
        uses MSDP-PEER-TIMER-BAG;
      }  // container peer-timer-values

      container peer-statistics {
        description "Peer statistics";
        uses MSDP-STATS-PEER-BAG;
      }  // container peer-statistics

      leaf local-address {
        type inet:ipv4-address;
        description "Local Address";
      }

      leaf local-port {
        type uint16;
        description "Local TCP Port";
      }

      leaf remote-port {
        type uint16;
        description "Remote TCP Port";
      }

      leaf ttl {
        type int32;
        description "TTL";
      }

      leaf write-queue-length {
        type int32;
        units "byte";
        description "Bytes on the writeQ";
      }

      leaf read-queue-length {
        type int32;
        units "byte";
        description "Bytes on the readQ";
      }

      leaf expires {
        type uint64;
        units "second";
        description
          "When the peer times out (seconds)";
      }

      leaf cleared {
        type uint64;
        units "second";
        description
          "last time cleared (seconds)";
      }

      leaf last-in-message-time-stamp {
        type uint64;
        description
          "last timestamp msg was received";
      }

      leaf established-time-stamp {
        type uint64;
        description
          "Timestamp when moved in/out of established state";
      }

      leaf sa-sent {
        type uint32;
        description "SA Sent";
      }

      leaf sa-received {
        type uint32;
        description "SA Received";
      }

      leaf discarded {
        type uint32;
        description
          "Output Messages blocked";
      }

      leaf in-sa-acl {
        type string;
        description "Incoming SA ACL";
      }

      leaf out-sa-acl {
        type string;
        description "Outgoing SA ACL";
      }

      leaf in-rp-acl {
        type string;
        description "Incoming RP ACL";
      }

      leaf out-rp-acl {
        type string;
        description "Outgoing RP ACL";
      }

      leaf incoming-sa-route-map {
        type string;
        description "Incoming SA route-map";
      }

      leaf outgoing-sa-route-map {
        type string;
        description "Outgoing SA route-map";
      }

      leaf incoming-rp-route-map {
        type string;
        description "Incoming RP route-map";
      }

      leaf outgoing-rp-route-map {
        type string;
        description "Outgoing RP route-map";
      }

      leaf sa-request-input-filter {
        type string;
        description "SA-Req input filter";
      }

      leaf mesh-group-name {
        type string;
        description "Mesh group  name";
      }

      leaf is-password-configured {
        type boolean;
        description
          "Has a peer password been configured for this
         peer";
      }

      leaf is-password-set-on-listen {
        type boolean;
        description
          "Has a peer password been set for this peer on
         the listen socket";
      }

      leaf is-password-set-on-active {
        type boolean;
        description
          "Has a peer password been set for this peer on
         the active socket";
      }

      leaf keep-alive-timer-period {
        type uint32;
        description "KeepAlive timer period";
      }

      leaf peer-time-out-timer-period {
        type uint32;
        description
          "Peer timeout timer period";
      }
    }  // grouping MSDP-PEER-BAG

    grouping MSDP-STATS-PEER-BAG {
      description "MSDP Peer Stats Bag";
      leaf peer-address-xr {
        type inet:ipv4-address;
        description "Peer's Address";
      }

      leaf as-number-string {
        type string;
        description "Peer's ASnum";
      }

      leaf peer-state {
        type Msdp-peer-state;
        description "Peer's State";
      }

      leaf sa-count {
        type uint32;
        description
          "SA count (entries with E flag set)";
      }

      leaf rpf-failures {
        type uint32;
        description "TLVs which failed RPF";
      }

      leaf rpf-enqueued {
        type uint32;
        description "TLVs enqueued";
      }

      leaf rpf-dequeued {
        type uint32;
        description "TLVs dequeued";
      }

      leaf keep-alive-received {
        type uint32;
        description
          "Keepalives type TLVs rcvd";
      }

      leaf notification-received {
        type uint32;
        description
          "Notification type TLVs rcvd";
      }

      leaf tlv-sa-received {
        type uint32;
        description "SA type TLVs rcvd";
      }

      leaf tlv-sa-request-received {
        type uint32;
        description
          "SA Request type TLVs rcvd";
      }

      leaf tlv-sa-response-received {
        type uint32;
        description
          "SA Response type TLVs rcvd";
      }

      leaf tlv-encapsulation-data-received {
        type uint32;
        description
          "SA Encap Data TLVs rcvd";
      }

      leaf tlv-unknown-received {
        type uint32;
        description "Unknown type TLVs rcvd";
      }

      leaf keep-alive-sent {
        type uint32;
        description
          "Keepalives type TLVs sent";
      }

      leaf notification-sent {
        type uint32;
        description
          "Notification type TLVs sent";
      }

      leaf tlv-sa-sent {
        type uint32;
        description "SA type TLVs sent";
      }

      leaf tlv-sa-request-sent {
        type uint32;
        description
          "SA Request type TLVs sent";
      }

      leaf tlv-sa-response {
        type uint32;
        description
          "SA Response type TLVs sent";
      }

      leaf tlv-encapsulation-data-sent {
        type uint32;
        description
          "SA Encap Data TLVs sent";
      }

      leaf sa-received {
        type uint32;
        description
          "Total SA messages received";
      }

      leaf sa-sent {
        type uint32;
        description "Total SA messages sent";
      }
    }  // grouping MSDP-STATS-PEER-BAG
  }  // submodule Cisco-IOS-XR-msdp-oper-sub1