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

    yang-version 1;

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

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

    include Cisco-IOS-XR-pim-oper-sub2 {
      revision-date "2021-02-17";
    }

    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 pim package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-02-17" {
      description
        "Addition made for Sticky DR neighbor tracking
       2020-10-11
         Changes to IOS-XR PIM oper";
    }

    revision "2019-12-24" {
      description "Fixed CSCvr52977.";
    }

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

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

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

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

    typedef Pim-show-local-interest {
      type enumeration {
        enum "null" {
          value 1;
          description "null";
        }
        enum "li" {
          value 2;
          description "Local Interest";
        }
        enum "ld" {
          value 3;
          description "Local Disinterest";
        }
      }
      description "Pim show local interest";
    }

    typedef Pim-internal-interest-info {
      type enumeration {
        enum "null" {
          value 21;
          description "null";
        }
        enum "ii" {
          value 22;
          description "Internal Interest";
        }
        enum "id" {
          value 23;
          description "Internal Disinterest";
        }
      }
      description
        "Pim internal interest info";
    }

    typedef Pim-show-range-client {
      type enumeration {
        enum "no-client" {
          value 0;
          description "no client";
        }
        enum "embedded-config" {
          value 1;
          description "embedded config";
        }
        enum "embedded" {
          value 2;
          description "embedded";
        }
        enum "permanent" {
          value 3;
          description "permanent";
        }
        enum "auto-rp" {
          value 4;
          description "auto rp";
        }
        enum "bsr" {
          value 5;
          description "bsr";
        }
        enum "config" {
          value 6;
          description "config";
        }
        enum "static" {
          value 7;
          description "static";
        }
      }
      description "Pim show range client";
    }

    typedef Pim-show-protocol {
      type enumeration {
        enum "no-route" {
          value 0;
          description "no route";
        }
        enum "sm" {
          value 1;
          description "sm";
        }
        enum "dm" {
          value 2;
          description "dm";
        }
        enum "bidir" {
          value 3;
          description "bidir";
        }
        enum "ssm" {
          value 4;
          description "ssm";
        }
        enum "maximum" {
          value 5;
          description "maximum";
        }
        enum "any" {
          value 6;
          description "any";
        }
      }
      description "Pim show protocol";
    }

    grouping PIM-ISSU-BAG {
      description "ISSU information";
      leaf informationvalid {
        type boolean;
        description "Is Information valid ?";
      }

      leaf role-ha {
        type int32;
        description "HA role";
      }

      leaf role-issu {
        type int32;
        description "ISSU role";
      }

      leaf phase-issu {
        type int32;
        description "ISSU Phase";
      }

      leaf last-ha-role-notification-received {
        type uint64;
        description
          "Time when last HA role nfn was received";
      }

      leaf last-issu-role-notification-received {
        type uint64;
        description
          "Time when last ISSU role nfn was received";
      }

      leaf last-issu-phase-notification-received {
        type uint64;
        description
          "Time when last ISSU Phase nfn was received";
      }

      leaf is-eoc-received {
        type boolean;
        description "Was EOC received ?";
      }

      leaf eoc-received-timestamp {
        type uint64;
        description
          "Time when EOC was received";
      }

      leaf is-ihms-done-received {
        type boolean;
        description
          "Was IHMS done received ?";
      }

      leaf ihms-received-timestamp {
        type uint64;
        description
          "Time when IHMS done was received";
      }

      leaf is-rib-sync-received {
        type boolean;
        description
          "Was RIB Sync received ?";
      }

      leaf rib-sync-received-timestamp {
        type uint64;
        description
          "Time when RIB Sync was received";
      }

      leaf is-nbr-sync-received {
        type boolean;
        description
          "Was NBR Sync achieved ?";
      }

      leaf nbr-sync-received-timestamp {
        type uint64;
        description
          "Time when NBR Sync was achieved";
      }

      leaf is-checkpoint-idt-done {
        type boolean;
        description
          "Was Checkpoint IDT done ?";
      }

      leaf checkpoint-idt-timestamp {
        type uint64;
        description
          "Time when Checkpoint IDT done";
      }
    }  // grouping PIM-ISSU-BAG

    grouping PIM-NSF-BAG {
      description "PIM NSF state";
      leaf configured-state {
        type boolean;
        description
          "Is Multicast NSF Configured";
      }

      leaf nsf-state {
        type boolean;
        description
          "Are we currently in NSF";
      }

      leaf nsf-timeout {
        type uint32;
        units "second";
        description
          "Multicast NSF timeout in seconds";
      }

      leaf nsf-time-left {
        type uint32;
        units "second";
        description
          "Multicast NSF time left in seconds";
      }

      leaf waiting-timer {
        type boolean;
        description
          "Waiting for NSF timer expiry";
      }

      leaf waiting-membership {
        type boolean;
        description "Waiting for IGMP/MLD";
      }

      leaf respawn-count {
        type uint32;
        description "Respawn Count";
      }

      leaf last-nsf-on {
        type int64;
        description "Last NSF time ON";
      }

      leaf last-nsf-off {
        type int64;
        description "Last NSF time off";
      }

      leaf last-nsf-on-sec {
        type int32;
        units "second";
        description
          "Last NSF time ON in Seconds";
      }

      leaf last-nsf-off-sec {
        type int32;
        units "second";
        description
          "Last NSF time OFF in Seconds";
      }

      leaf last-icd-notif-recv {
        type int64;
        description "Last ICD Notif Recv";
      }

      leaf last-icd-notif-recv-sec {
        type int32;
        units "second";
        description
          "Last ICD Notif Recv in Seconds";
      }
    }  // grouping PIM-NSF-BAG

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

      leaf partner-connected {
        type boolean;
        description
          "Partner process connected";
      }

      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-connection-up {
        type uint64;
        description
          "Time when connection went up";
      }

      leaf last-connection-dn {
        type uint64;
        description
          "Time when connection went down";
      }

      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-connection-up {
        type uint32;
        description
          "No. of times connection went up";
      }

      leaf count-connection-dn {
        type uint32;
        description
          "No. of times connection went down";
      }

      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";
      }
    }  // grouping PIM-NSR-BAG

    grouping PIM-NBR-BAG {
      description "PIM neighbor information";
      leaf interface-name-xr {
        type xr:Interface-name;
        description "Interface Identifier";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expires {
        type uint64;
        units "second";
        description
          "Neighbor expiry in seconds";
      }

      leaf expiry-timer {
        type uint64;
        units "second";
        description
          "Expiry timer in seconds";
      }

      leaf is-this-neighbor-us {
        type boolean;
        description "Is this neighbor us ?";
      }

      leaf is-this-neighbor-dr {
        type boolean;
        description
          "Is this neighbor the DR";
      }

      leaf is-dr-priority-capable {
        type boolean;
        description
          "Is this neighbor DR priority capable ?";
      }

      leaf dr-priority {
        type uint32;
        description "DR priority";
      }

      leaf is-bidirectional-capable {
        type boolean;
        description
          "Is this neighbor bidir capable ?";
      }

      leaf is-proxy-capable {
        type boolean;
        description
          "Is this neighbor proxy capable?";
      }

      leaf is-batch-asserts-capable {
        type boolean;
        description
          "Is this neighbor capable of batching asserts?";
      }

      leaf is-ecmp-redirect-capable {
        type boolean;
        description
          "Is this neighbor capable of Ecmp Redirect?";
      }

      leaf is-bfd-state {
        type boolean;
        description
          "Is the neighbor bfd session created";
      }

      leaf sticky-dr-neighbor {
        type boolean;
        description
          "Is Sticky DR advertised on interface by neighbor";
      }

      leaf propagation-delay {
        type uint16;
        description "Propagation Delay";
      }

      leaf override-interval {
        type uint16;
        description "Override Interval";
      }

      list neighbor-address-xr {
        description
          "List of Neighbor Addresses";
        uses PIM-ADDRTYPE;
      }  // list neighbor-address-xr
    }  // grouping PIM-NBR-BAG

    grouping PIM-MSTATIC-BAG {
      description
        "Multicast Static Routes entry";
      container prefix {
        description "Prefix";
        uses PIM-ADDRTYPE;
      }  // container prefix

      container nexthop {
        description "Next Hop";
        uses PIM-ADDRTYPE;
      }  // container nexthop

      leaf interface-name {
        type xr:Interface-name;
        description "Interface Handle";
      }

      leaf distance {
        type uint32;
        description "Distance";
      }

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

      leaf is-via-lsm {
        type boolean;
        description "LSM flag";
      }
    }  // grouping PIM-MSTATIC-BAG

    grouping PIM-RPF-RDRCT-BNDL-BAG {
      description
        "PIM RPF Redirect bundle information";
      leaf rpf-redirect-bundle-name {
        type string {
          length "0..33";
        }
        description
          "RPF redirect bundle name";
      }

      leaf rpf-redirect-interface-name {
        type string {
          length "0..33";
        }
        description
          "RPF redirect interface name";
      }

      leaf available-bandwidth {
        type int32;
        units "kbit/s";
        description
          "Bandwidth available in Kbps";
      }

      leaf allocated-bandwidth {
        type int32;
        units "kbit/s";
        description
          "Bandwidth allocated in Kbps";
      }

      leaf total-bandwidth {
        type int32;
        units "kbit/s";
        description
          "Total bandwidth used in Kbps";
      }

      leaf topology-bandwidth-used {
        type int32;
        units "kbit/s";
        description
          "Bandwidth used by topology in Kbps";
      }

      leaf snooping-bandwidth-used {
        type int32;
        units "kbit/s";
        description
          "Bandwidth used by snooped entries in Kbps";
      }

      leaf allocated-threshold-bandwidth {
        type int32;
        units "kbit/s";
        description
          "Configured threshold in Kbps";
      }

      leaf available-threshold-bandwidth {
        type int32;
        units "kbit/s";
        description
          "Available threshold in Kbps";
      }
    }  // grouping PIM-RPF-RDRCT-BNDL-BAG

    grouping PIM-RPF-RDRCT-RINTF-BAG {
      description
        "PIM RPF-redirct bundle non-local route OLE
       information";
      container rpf-address {
        description "RPF Address";
        uses PIM-ADDRTYPE;
      }  // container rpf-address

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

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expiry {
        type uint64;
        units "second";
        description "Expiry in seconds";
      }

      leaf is-rpf-interface {
        type boolean;
        description "Is RPF Interface";
      }

      leaf is-outgoing-interface {
        type boolean;
        description "Is outgoing Interface";
      }

      leaf is-snoop-interface {
        type boolean;
        description "Is snooping Interface";
      }
    }  // grouping PIM-RPF-RDRCT-RINTF-BAG

    grouping PIM-RPF-RDRCT-ROUTE-BAG {
      description
        "PIM RPF Redirect route information";
      container group-address-xr {
        description "Group ddress";
        uses PIM-ADDRTYPE;
      }  // container group-address-xr

      container source-address-xr {
        description "Source address";
        uses PIM-ADDRTYPE;
      }  // container source-address-xr

      leaf bandwidth {
        type uint32;
        units "kbit/s";
        description "Bandwidth in Kbps";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      list interface {
        description
          "Outgoing interface list";
        uses PIM-RPF-RDRCT-RINTF-BAG;
      }  // list interface
    }  // grouping PIM-RPF-RDRCT-ROUTE-BAG

    grouping PIM-ANYCAST-RP-ENTRY {
      description "PIM Anycast RP entry";
      container prefix {
        description
          "Anycast-RP Range Prefix";
        uses PIM-ADDRTYPE;
      }  // container prefix

      leaf prefix-length {
        type uint8;
        description
          "Anycast-RP Range Prefix Length";
      }

      leaf ancast-rp-marked {
        type boolean;
        description
          "Anycast-RP Range marked";
      }
    }  // grouping PIM-ANYCAST-RP-ENTRY

    grouping PIM-RT-EXTCOMM {
      description "PIM Route-target entry";
      leaf route-target {
        type yang:hex-string;
        description
          "Route Target Extended community value";
      }

      leaf configured {
        type boolean;
        description
          "Configured Route Target";
      }

      leaf anycast-rp {
        type boolean;
        description "Anycast-RP Group";
      }

      leaf anycast-rp-marked {
        type boolean;
        description
          "Anycast-RP Group marked";
      }

      leaf update-pending {
        type boolean;
        description "Update Pending to BGP";
      }

      leaf bgp-auto-discovery {
        type boolean;
        description "BGP Auto Discovery";
      }

      leaf segment-border {
        type boolean;
        description "Segment Border";
      }
    }  // grouping PIM-RT-EXTCOMM

    grouping PIM-CONTEXT-BAG {
      description "PIM Context bag";
      container remote-default-group {
        description "Remote Default Group";
        uses PIM-ADDRTYPE;
      }  // container remote-default-group

      container rpf-default-table {
        description "RPF Default Table";
        uses PIM-TABLE-CTX-BAG;
      }  // container rpf-default-table

      leaf vrf-id {
        type uint32;
        description "VRF ID";
      }

      leaf table-id {
        type uint32;
        description "Table ID";
      }

      leaf murib-id {
        type uint32;
        description "MURIB ID";
      }

      leaf rpf-id {
        type uint32;
        description "RPF ID";
      }

      leaf remote-table-id {
        type uint32;
        description "Remote Table ID";
      }

      leaf mdt-default-group {
        type inet:ipv4-address;
        description "MDT Default group";
      }

      leaf mdt-source {
        type inet:ipv4-address;
        description "MDT source";
      }

      leaf mdt-source-interface {
        type string;
        description
          "MDT Source Interface Name";
      }

      leaf mdt-interface {
        type xr:Interface-name;
        description "MDT handle";
      }

      leaf mdt-gre-rpf-identifier {
        type uint32;
        description "GRE-MDT RPF Identifier";
      }

      leaf mdt-gre-remote-rpf-identifier {
        type uint32;
        description
          "GRE-MDT Remote RPF Identifier";
      }

      leaf is-unicast-rib-registration {
        type boolean;
        description "Ucast RIB Registration";
      }

      leaf is-multicast-rib-registration {
        type boolean;
        description "Mcast RIB Registration";
      }

      leaf is-active {
        type boolean;
        description "Active";
      }

      leaf is-active-ital {
        type boolean;
        description "Active ITAL";
      }

      leaf is-mrib-register {
        type boolean;
        description "MRIB Register";
      }

      leaf is-mdt-owner {
        type boolean;
        description "MDT Owner";
      }

      leaf is-routing-enabled {
        type boolean;
        description "Routing Enabled";
      }

      leaf is-socket-add-required {
        type boolean;
        description "VRF required on Socket";
      }

      leaf is-socket-added {
        type boolean;
        description "VRF added on Socket";
      }

      leaf is-lpts-socket-add-required {
        type boolean;
        description
          "VRF LPTS filter required on Socket";
      }

      leaf is-lpts-socket-added {
        type boolean;
        description
          "VRF LPTS filter added on Socket";
      }

      leaf is-udp-socket-add-required {
        type boolean;
        description
          "VRF added on UDP Socket";
      }

      leaf is-udp-socket-added {
        type boolean;
        description
          "VRF added on UDP Socket";
      }

      leaf is-udp-socket-bind-required {
        type boolean;
        description
          "VRF bind required on UDP Socket";
      }

      leaf is-udp-socket-bind {
        type boolean;
        description
          "VRF bound on UDP Socket";
      }

      leaf is-register-injection-socket-add-required {
        type boolean;
        description
          "VRF required on Register Injection Socket";
      }

      leaf is-register-injection-socket-added {
        type boolean;
        description
          "VRF added on Register Injection Socket";
      }

      leaf is-register-injection-lpts-socket-add-required {
        type boolean;
        description
          "VRF LPTS filter required on Register Injection
         Socket";
      }

      leaf is-register-injection-lpts-socket-added {
        type boolean;
        description
          "VRF LPTS filter added on Register Injection
         Socket";
      }

      leaf is-m-host-publish-pending {
        type boolean;
        description
          "Publish pending for MHost Default interface";
      }

      leaf mhost-interface {
        type xr:Interface-name;
        description "MHost handle";
      }

      leaf mhost-default-interface-config {
        type string;
        description
          "Configured Mhost Defint";
      }

      leaf mdt-mtu {
        type uint32;
        description "MDT MTU";
      }

      leaf maximum-mdt-aggregation {
        type uint32;
        description "MDT max aggregation";
      }

      leaf mdt-data-switchover-interval {
        type uint32;
        description
          "Data MDT Switchover interval";
      }

      leaf mdt-data-announce-interval {
        type uint32;
        description
          "Data MDT Announce interval";
      }

      leaf non-default-vrf-count-on-socket {
        type uint32;
        description
          "Count of non-default vrfs on raw socket";
      }

      leaf neighbor-filter-name {
        type string;
        description "Neighbor Filter Name";
      }

      leaf mdt-neighbor-filter-name {
        type string;
        description
          "MDT Neighbor Filter Name";
      }

      leaf allow-rp-configured {
        type boolean;
        description "Allow RP Configured";
      }

      leaf allow-rp-group-list {
        type string {
          length "0..64";
        }
        description
          "Allow RP Group-List ACL Name";
      }

      leaf allow-rp-rp-list {
        type string {
          length "0..64";
        }
        description
          "Allow RP RP-list ACL Name";
      }

      leaf sg-expiry-timer-configured {
        type boolean;
        description
          "S,G Expiry Timer Configured";
      }

      leaf sg-expiry-time {
        type uint16;
        units "second";
        description
          "S,G Expiry Time Configured, in seconds";
      }

      leaf sg-expiry-timer-sg-list {
        type string {
          length "0..64";
        }
        description
          "S,G expiry timer ACL name";
      }

      leaf mldp-mdt-name {
        type string;
        description "MLDP MDT Name";
      }

      leaf mldp-mdt-interface {
        type xr:Interface-name;
        description "MLDP MDT handle";
      }

      leaf mldp-mdt-mtu {
        type uint32;
        description "MLDP MDT MTU";
      }

      leaf mldp-maximum-mdt-aggregation {
        type uint32;
        description
          "MLDP MDT max aggregation";
      }

      leaf mldp-mdt-data-switchover-interval {
        type uint32;
        description
          "MLDP Data MDT Switchover interval";
      }

      leaf mldp-mdt-data-announce-interval {
        type uint32;
        description
          "MLDP Data MDT Announce interval";
      }

      leaf mldp-mdt-rpf-identifier {
        type uint32;
        description "MLDP RPF-ID";
      }

      leaf mldp-mdt-remote-rpf-identifier {
        type uint32;
        description "MLDP Remote RPF-ID";
      }

      leaf is-create-mldp-mdt-interface {
        type boolean;
        description
          "Create MLDP MDT interface";
      }

      leaf is-mldp-mdt-owner {
        type boolean;
        description "MLDP MDT Owner";
      }

      leaf mldp-root-count {
        type uint32;
        description "MLDP Root count";
      }

      leaf mldp-head-lsm-identifier {
        type uint32;
        description "MLDP Head LSM-ID";
      }

      leaf mldp-remote-head-lsm-identifier {
        type uint32;
        description
          "MLDP Remote Head LSM-ID";
      }

      leaf organization-unique-identifier {
        type uint32;
        description "OUI for VPN-ID";
      }

      leaf vpn-index {
        type uint32;
        description "VPN Index";
      }

      leaf mldp-partitioned-mdt-configured {
        type boolean;
        description "MLDP Partitioned MDT";
      }

      leaf mldp-remote-partitioned-mdt-configured {
        type boolean;
        description
          "MLDP Remote Partitioned MDT";
      }

      leaf mldp-partioned-mp2m-ptree {
        type boolean;
        description
          "MP2MP Partitioned MDT tree";
      }

      leaf mldp-partitioned-head-lsm-identifier {
        type uint32;
        description
          "Partitioned MDT Head LSM-ID";
      }

      leaf mldp-head-local-label {
        type uint32;
        description
          "Partitioned MDT Head local label";
      }

      leaf mldp-partitioned-mdt-identifier {
        type uint32;
        description
          "MLDP Partitioned MDT Identifier";
      }

      leaf bgp-auto-discovery-configured {
        type boolean;
        description
          "BGP Auto-Discovery configured";
      }

      leaf suppress-pim-data-mdt-tlv {
        type boolean;
        description
          "Suppress PIM Data-MDT TLV Announcements";
      }

      leaf inter-autonomous-system-enabled {
        type boolean;
        description "Inter-AS Enabled";
      }

      leaf bgp-source-active-announce {
        type boolean;
        description
          "Send BGP Source-Active Announcements";
      }

      leaf bgp-i-pmsi-added {
        type boolean;
        description "BGP I-PMSI Added";
      }

      leaf mldp-bsr-control-tree-added {
        type boolean;
        description
          "MLDP BSR Control tree added";
      }

      leaf mldp-auto-rp-discovery-tree-added {
        type boolean;
        description
          "MLDP Autorp Discovery Control tree added";
      }

      leaf mldp-auto-rp-announce-tree-added {
        type boolean;
        description
          "MLDP Autorp Announce Control tree added";
      }

      leaf bgp-auto-discovery-type {
        type uint32;
        description
          "BGP Auto Discovery Type";
      }

      leaf mdt-partitioned-mdt-control-identifier {
        type uint32;
        description
          "Partitioned MDT Control Identifier";
      }

      leaf mdt-partitioned-ir-control-identifier {
        type uint32;
        description
          "Partitioned IR MDT Control Identifier";
      }

      leaf mldp-control-head-lsm-identifier {
        type uint32;
        description "MLDP MVPN Identifier";
      }

      leaf umh {
        type boolean;
        description "Join UMH Core-Tree";
      }

      leaf suppress-shared-tree-join {
        type boolean;
        description
          "Suppress Shared-Tree Joins";
      }

      leaf rsvp-te-mdt-name {
        type string;
        description "RSVP-TE MDT Name";
      }

      leaf rsvp-te-mdt-interface {
        type xr:Interface-name;
        description "RSVP-TEMDT handle";
      }

      leaf rsvp-te-mdt-mtu {
        type uint32;
        description "RSVP-TEMDT MTU";
      }

      leaf rsvp-te-maximum-mdt-aggregation {
        type uint32;
        description
          "RSVP-TE MDT max aggregation";
      }

      leaf rsvp-te-mdt-data-switchover-interval {
        type uint32;
        description
          "RSVP-TE Data MDT Switchover interval";
      }

      leaf rsvp-te-mdt-data-announce-interval {
        type uint32;
        description
          "RSVP-TE Data MDT Announce interval";
      }

      leaf rsvp-te-mdt-rpf-identifier {
        type uint32;
        description "RSVP-TE RPF-ID";
      }

      leaf is-create-rsvp-te-mdt-interface {
        type boolean;
        description
          "Create RSVP-TE MDT interface";
      }

      leaf is-rsvp-te-mdt-owner {
        type boolean;
        description "RSVP-TE MDT Owner";
      }

      leaf rsvp-te-mdt-static-p2mp-count {
        type uint32;
        description
          "Number of Static P2MP-TE MDT";
      }

      leaf p2mpte-li-drop {
        type uint32;
        description
          "Route LI updates dropped for P2MP";
      }

      leaf ir-mdt-name {
        type string;
        description "IR MDT Name";
      }

      leaf ir-mdt-interface {
        type xr:Interface-name;
        description "IRMDT handle";
      }

      leaf ir-mdt-mtu {
        type uint32;
        description "IRMDT MTU";
      }

      leaf ir-maximum-mdt-aggregation {
        type uint32;
        description "IR MDT max aggregation";
      }

      leaf ir-mdt-data-switchover-interval {
        type uint32;
        description
          "IR Data MDT Switchover interval";
      }

      leaf ir-mdt-data-announce-interval {
        type uint32;
        description
          "IR Data MDT Announce interval";
      }

      leaf ir-mdt-rpf-identifier {
        type uint32;
        description "IR RPF-ID";
      }

      leaf ir-mdt-tail-label {
        type uint32;
        description "IR Tail Label";
      }

      leaf is-create-ir-mdt-interface {
        type boolean;
        description
          "Create IR MDT interface";
      }

      leaf is-ir-mdt-owner {
        type boolean;
        description "IR MDT Owner";
      }

      leaf is-sr-local {
        type boolean;
        description "SR Local";
      }

      leaf is-sr-remote {
        type boolean;
        description "SR Remote";
      }

      leaf sr-mdt-name {
        type string;
        description "SR MDT Name";
      }

      leaf sr-mdt-interface {
        type xr:Interface-name;
        description "SRMDT handle";
      }

      leaf sr-mdt-mtu {
        type uint32;
        description "SRMDT MTU";
      }

      leaf sr-maximum-mdt-aggregation {
        type uint32;
        description "SR MDT max aggregation";
      }

      leaf sr-mdt-data-switchover-interval {
        type uint32;
        description
          "SR Data MDT Switchover interval";
      }

      leaf sr-mdt-data-announce-interval {
        type uint32;
        description
          "SR Data MDT Announce interval";
      }

      leaf sr-mdt-rpf-identifier {
        type uint32;
        description "SR RPF-ID";
      }

      leaf sr-mdt-tail-label {
        type uint32;
        description "SR Tail Label";
      }

      leaf is-create-sr-mdt-interface {
        type boolean;
        description
          "Create SR MDT interface";
      }

      leaf is-sr-mdt-owner {
        type boolean;
        description "SR MDT Owner";
      }

      leaf mdt-partitioned-tree-sid-control-identifier {
        type uint32;
        description
          "Partitioned Tree-SID MDT Control Identifier";
      }

      leaf in-b-and-mdt-name {
        type string;
        description "Inband MDT Name";
      }

      leaf in-b-and-mdt-interface {
        type xr:Interface-name;
        description "Inband MDT handle";
      }

      leaf in-b-and-mdt-mtu {
        type uint32;
        description "Inband MDT MTU";
      }

      leaf in-band-maximum-mdt-aggregation {
        type uint32;
        description
          "Inband MDT max aggregation";
      }

      leaf in-b-and-mdt-data-switchover-interval {
        type uint32;
        description
          "Inband Data MDT Switchover interval";
      }

      leaf in-b-and-mdt-data-announce-interval {
        type uint32;
        description
          "Inband Data MDT Announce interval";
      }

      leaf in-b-and-mdt-rpf-identifier {
        type uint32;
        description "Inband RPF-ID";
      }

      leaf is-create-in-b-and-mdt-interface {
        type boolean;
        description
          "Create Inband MDT interface";
      }

      leaf is-in-b-and-mdt-owner {
        type boolean;
        description "Inband MDT Owner";
      }

      leaf in-band-signaling-local-enabled {
        type boolean;
        description
          "Inband signaling Local enabled";
      }

      leaf in-band-signaling-remote-enabled {
        type boolean;
        description
          "Inband signaling Remote enabled";
      }

      leaf valid-rd-present {
        type boolean;
        description "RD is valid";
      }

      leaf stale-rd-present {
        type boolean;
        description "RD is stale";
      }

      leaf route-distinguisher {
        type yang:hex-string;
        description "RD value";
      }

      leaf gin-b-and-mdt-name {
        type string;
        description "Inband MDT Name";
      }

      leaf gin-b-and-mdt-interface {
        type xr:Interface-name;
        description "Inband MDT handle";
      }

      leaf gin-b-and-mdt-mtu {
        type uint32;
        description "Inband MDT MTU";
      }

      leaf gin-band-maximum-mdt-aggregation {
        type uint32;
        description
          "Inband MDT max aggregation";
      }

      leaf gin-b-and-mdt-data-switchover-interval {
        type uint32;
        description
          "Inband Data MDT Switchover interval";
      }

      leaf gin-b-and-mdt-data-announce-interval {
        type uint32;
        description
          "Inband Data MDT Announce interval";
      }

      leaf gin-b-and-mdt-rpf-identifier {
        type uint32;
        description "Inband RPF-ID";
      }

      leaf is-create-gin-b-and-mdt-interface {
        type boolean;
        description
          "Create Inband MDT interface";
      }

      leaf is-gin-b-and-mdt-owner {
        type boolean;
        description "Inband MDT Owner";
      }

      leaf is-pim-nsf-rib-converged {
        type boolean;
        description "PIM NSF RIB converged";
      }

      leaf is-pim-nsf-rib-converge-received {
        type boolean;
        description
          "PIM NSF RIB converge received";
      }

      leaf is-rib-multipath-enabled {
        type boolean;
        description
          "PIM RIB multiplath enabled";
      }

      leaf is-rib-multipath-interface-hash {
        type boolean;
        description
          "PIM RIB multipath interface hash";
      }

      leaf is-rib-multipath-source-hash {
        type boolean;
        description
          "PIM RIB multipath source based hash";
      }

      leaf is-rib-multipath-source-next-hop-hash {
        type boolean;
        description
          "PIM RIB multipath source-nexthop hash";
      }

      leaf rump-enabled {
        type boolean;
        description "PIM is using MuRIB";
      }

      leaf is-create-mdt-interface {
        type boolean;
        description "Create MDT interface";
      }

      leaf is-auto-rp-listen-enabled {
        type boolean;
        description "Auto RP Listen Enabled";
      }

      leaf is-all-interface-disable-operation {
        type boolean;
        description
          "PIM all interface disable operation";
      }

      leaf is-default-granges {
        type boolean;
        description "Default granges";
      }

      leaf is-auto-rp-listen-sock-add {
        type boolean;
        description
          "Auto RP listen sock add";
      }

      leaf is-redistribution-reset {
        type boolean;
        description "Pending redist reset";
      }

      leaf redistribution-reset-count {
        type uint32;
        description "Redist reset count";
      }

      leaf rpf-policy-name {
        type string;
        description
          "RPF topology selection route-policy name";
      }

      leaf table-count {
        type uint32;
        description
          "Number of configured Tables";
      }

      leaf active-table-count {
        type uint32;
        description
          "Number of active Tables";
      }

      leaf anycast-rp-policy-name {
        type string;
        description "Anycast-RP Policy Name";
      }

      leaf anycast-rp-configured {
        type boolean;
        description "Anycast-RP config";
      }

      leaf bgp-remote-on {
        type boolean;
        description
          "BGP remote interface status";
      }

      leaf bgp-remote-interface-name {
        type string;
        description
          "BGP remote interface name";
      }

      leaf bgp-remote-interface {
        type xr:Interface-name;
        description
          "BGP remote interface handle";
      }

      leaf bgp-remote-address {
        type inet:ipv4-address;
        description
          "BGP remote interface address";
      }

      leaf bgp-remote-state {
        type uint32;
        description
          "BGP remote interface state";
      }

      leaf physical-interface-count {
        type uint64;
        description
          "Enabled Physical Interface Count";
      }

      leaf virtual-interface-count {
        type uint64;
        description
          "Enabled Virtual Interface Count";
      }

      leaf virtual-mlc-interface-name {
        type string;
        description
          "Virtual master line card Interface";
      }

      leaf mdt-immediate-switch {
        type boolean;
        description "MDT Immediate Switch";
      }

      leaf remote-mdt-idb-name {
        type string;
        description
          "Remote MDT Interface Handle Name";
      }

      leaf remote-mdt-address {
        type inet:ipv4-address;
        description
          "Remote MDT interface address";
      }

      leaf-list mldp-root-address {
        type uint32;
        description "MLDP Root addresses";
      }

      list export-route-target {
        description "Export Route Targets";
        uses PIM-RT-EXTCOMM;
      }  // list export-route-target

      list import-route-target {
        description "Import Route Targets";
        uses PIM-RT-EXTCOMM;
      }  // list import-route-target

      list anycast-rp-range {
        description "Anycast-RP Ranges";
        uses PIM-ANYCAST-RP-ENTRY;
      }  // list anycast-rp-range
    }  // grouping PIM-CONTEXT-BAG

    grouping PIM-NBR-SUMM-BAG {
      description "PIM neighbor summary";
      leaf number-of-neighbors {
        type int32;
        description "Number of neighbors";
      }

      leaf number-of-external-neighbors {
        type int32;
        description
          "Number of external neighbors";
      }
    }  // grouping PIM-NBR-SUMM-BAG

    grouping PIM-TABLE-CTX-BAG {
      description "PIM Table context";
      leaf afi {
        type uint32;
        description "AFI";
      }

      leaf safi {
        type uint32;
        description "SAFI";
      }

      leaf table-name {
        type string;
        description "Table name";
      }

      leaf vrf-id {
        type uint32;
        description "VRF ID";
      }

      leaf table-id {
        type uint32;
        description "Table ID";
      }

      leaf is-active {
        type boolean;
        description "Active status";
      }

      leaf is-ital-registration-done {
        type boolean;
        description "ITAL reg status";
      }

      leaf is-rib-registration-done {
        type boolean;
        description "RIB reg status";
      }

      leaf is-rib-convergence-received {
        type boolean;
        description
          "RIB Convergence receive status";
      }

      leaf is-rib-convergence {
        type boolean;
        description "RIB Convergence status";
      }

      leaf rpf-registrations {
        type uint32;
        description "RPF Registration count";
      }
    }  // grouping PIM-TABLE-CTX-BAG

    grouping PIM-BIDIR-DF-BAG {
      description
        "PIM Bidirectional DF entry";
      container rp-address-xr {
        description "RP Address";
        uses PIM-ADDRTYPE;
      }  // container rp-address-xr

      container df-winner {
        description "DF Winner";
        uses PIM-ADDRTYPE;
      }  // container df-winner

      leaf pim-interface-name {
        type string;
        description "Interface Name";
      }

      leaf are-we-df {
        type boolean;
        description "Are we DF";
      }

      leaf rp-lan {
        type boolean;
        description "Is this the RP LAN";
      }

      leaf metric {
        type uint32;
        description "Metric";
      }

      leaf metric-preference {
        type uint32;
        description "Metric Preference";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }
    }  // grouping PIM-BIDIR-DF-BAG

    grouping PIM-GRE-PATH-BAG {
      description "PIM GRE path information";
      container gre-neighbor {
        description "GRE neighbor";
        uses PIM-ADDRTYPE;
      }  // container gre-neighbor

      container gre-next-hop {
        description "GRE nexthop";
        uses PIM-ADDRTYPE;
      }  // container gre-next-hop

      leaf gre-interface-name {
        type xr:Interface-name;
        description "GRE Interface";
      }

      leaf is-gre-interface-disabled {
        type boolean;
        description
          "Is the gre interface disabled ?";
      }

      leaf is-via-lsm {
        type boolean;
        description "Via LSM";
      }

      leaf is-connector-attribute-present {
        type boolean;
        description
          "Connector attribute present";
      }

      leaf extranet-vrf-name {
        type string {
          length "0..33";
        }
        description "Extranet VRF name";
      }
    }  // grouping PIM-GRE-PATH-BAG

    grouping PIM-GRE-INFO-BAG {
      description "PIM GRE information";
      container registered-address {
        description "Address registered";
        uses PIM-ADDRTYPE;
      }  // container registered-address

      leaf metric {
        type uint32;
        description "Metric";
      }

      leaf metric-preference {
        type uint32;
        description "Metric preference";
      }

      leaf is-connected {
        type uint8;
        description "Are we connected ?";
      }

      list gre-path {
        description "GRE Paths list";
        uses PIM-GRE-PATH-BAG;
      }  // list gre-path
    }  // grouping PIM-GRE-INFO-BAG

    grouping PIM-SUMMARY-BAG {
      description "PIM Summary Bag";
      leaf route-limit {
        type uint32;
        description "Maximum routes";
      }

      leaf route-count {
        type uint32;
        description "Current routes";
      }

      leaf route-low-water-mark {
        type uint32;
        description
          "The number of routes below which the throttle on
         route creation will be lifted";
      }

      leaf is-route-limit-reached {
        type boolean;
        description
          "Is route creation throttled";
      }

      leaf topology-interface-state-limit {
        type uint32;
        description
          "Maximum Topology Interface State count";
      }

      leaf topology-interface-state-count {
        type uint32;
        description
          "Current Topology Interface State count";
      }

      leaf rxi-low-water-mark {
        type uint32;
        description
          "The rxi below which the throttle on interface
         creation will be lifted";
      }

      leaf rxi-limit-reached {
        type boolean;
        description
          "Is interface creation throttled";
      }

      leaf register-limit {
        type uint32;
        description "Maximum registers";
      }

      leaf register-count {
        type uint32;
        description "Current registers";
      }

      leaf register-limit-reached {
        type boolean;
        description
          "Is PIM SM register handling throttled";
      }

      leaf ranges-limit {
        type uint32;
        description
          "Maximum group ranges from Autorp";
      }

      leaf ranges-count {
        type uint32;
        description
          "Current group ranges from Autorp";
      }

      leaf ranges-threshold {
        type uint32;
        description
          "OOR theshold of grange ranges from AutoRP";
      }

      leaf is-ranges-limit-reached {
        type boolean;
        description
          "Is Auto-RP group-to-RP mapping range creation
         throttled";
      }

      leaf bsr-ranges-limit {
        type uint32;
        description
          "Maximum group ranges from BSR";
      }

      leaf bsr-ranges-count {
        type uint32;
        description
          "Current group ranges from BSR";
      }

      leaf bsr-range-threshold {
        type uint32;
        description
          "Threshold group range from BSR";
      }

      leaf is-bsr-ranges-threshold-reached {
        type boolean;
        description
          "Is VRF-specific BSR group-to-RP mapping range
         creation throttled";
      }

      leaf bsr-candidate-rp-set-limit {
        type uint32;
        description
          "Maximum crp-set from BSR";
      }

      leaf bsr-candidate-rp-set-count {
        type uint32;
        description
          "Current crp-set count from BSR";
      }

      leaf bsr-candidate-rp-set-threshold {
        type uint32;
        description
          "Threshold crp-set from BSR";
      }

      leaf is-maximum-enforcement-disabled {
        type boolean;
        description
          "Is maximum enforcement disabled";
      }

      leaf is-node-low-memory {
        type boolean;
        description
          "Is node in low memory condition";
      }

      leaf route-threshold {
        type uint32;
        description "Threshold routes";
      }

      leaf global-auto-rp-ranges-limit {
        type uint32;
        description
          "Global Auto-RP maximum group ranges";
      }

      leaf is-global-auto-rp-ranges-limit-reached {
        type boolean;
        description
          "Is global AutoRP group-to-RP mapping range
         creation throttled";
      }

      leaf global-bsr-ranges-limit {
        type uint32;
        description
          "Global BSR maximum group ranges";
      }

      leaf global-bsr-ranges-count {
        type uint32;
        description
          "Global BSR current group ranges";
      }

      leaf global-bsr-ranges-threshold {
        type uint32;
        description
          "Global BSR Threshold group ranges";
      }

      leaf is-global-bsr-ranges-limit-reached {
        type boolean;
        description
          "Is global BSR group-to-RP mapping range creation
         throttled";
      }

      leaf global-bsr-candidate-rp-set-limit {
        type uint32;
        description
          "Global BSR maximum crp-set";
      }

      leaf global-bsr-candidate-rp-set-count {
        type uint32;
        description
          "Global BSR current crp-set count";
      }

      leaf global-bsr-candidate-rp-set-threshold {
        type uint32;
        description
          "Global BSR Threshold crp-set";
      }

      leaf is-global-route-limit-reached {
        type boolean;
        description
          "Is global route creation throttled";
      }

      leaf topology-interface-state-threshold {
        type uint32;
        description
          "Topology Interface State threshold";
      }

      leaf is-global-rxi-limit-reached {
        type boolean;
        description
          "Is global interface creation throttled";
      }

      leaf register-threshold {
        type uint32;
        description "Threshold registers";
      }

      leaf global-register-limit {
        type uint32;
        description
          "Maximum global registers";
      }

      leaf is-global-register-limit-reached {
        type boolean;
        description
          "Is global PIM SM register handling throttled";
      }
    }  // grouping PIM-SUMMARY-BAG

    grouping PIM-GRP-MAP-INFORPF-BAG {
      description
        "PIM group-map information";
      container rpf-neighbor {
        description "RPF neighbor to the RP";
        uses PIM-ADDRTYPE;
      }  // container rpf-neighbor

      container group-map-information {
        description
          "Group Mapping information";
        uses PIM-GRP-MAP-BAG;
      }  // container group-map-information

      leaf are-we-rp {
        type boolean;
        description "Are we the RP?";
      }

      leaf rpf-interface-name {
        type xr:Interface-name;
        description
          "RPF interface to the RP";
      }

      leaf rpf-vrf-name {
        type string {
          length "0..33";
        }
        description "RPF VRF Name";
      }
    }  // grouping PIM-GRP-MAP-INFORPF-BAG

    grouping PIM-PKTQ-STATS {
      description
        "PIM packet queue statistics per priority";
      leaf enqueued-packets {
        type uint32;
        description
          "Total number of packets enqueued to this queue";
      }

      leaf dequeued-packets {
        type uint32;
        description
          "Total number of packets dequeued from this queue";
      }

      leaf high-water-mark-packets {
        type uint32;
        description
          "Highest number of packets enqueued in this queue";
      }

      leaf high-water-mark-bytes {
        type uint32;
        units "byte";
        description
          "Highest number of bytes enqueued in this queue";
      }

      leaf tail-drops {
        type uint32;
        description
          "Number packets dropped from this queue due to
         max size";
      }
    }  // grouping PIM-PKTQ-STATS

    grouping PIM-PKTQ-STATE {
      description
        "PIM packet queue state per priority";
      leaf max-queue-size {
        type uint32;
        units "byte";
        description
          "Maximum size of queue in bytes";
      }

      leaf queue-size-bytes {
        type uint32;
        units "byte";
        description "Size of queue in bytes";
      }

      leaf queue-size-packets {
        type uint32;
        description
          "Size of queue in number of packets";
      }
    }  // grouping PIM-PKTQ-STATE

    grouping PIM-PKTQ {
      description
        "PIM packet queue state and statistics";
      container packet-queue-state {
        description "State of the queue";
        uses PIM-PKTQ-STATE;
      }  // container packet-queue-state

      container packet-queue-stats {
        description
          "Statistics about the queue";
        uses PIM-PKTQ-STATS;
      }  // container packet-queue-stats

      leaf packet-queue-priority {
        type uint32;
        description
          "Priority of this packet queue";
      }
    }  // grouping PIM-PKTQ

    grouping PIM-TRAFFIC-BAG {
      description "PIM Traffic counters";
      leaf elapsed-time {
        type uint32;
        units "second";
        description
          "Running time for counters in seconds";
      }

      leaf inputs {
        type uint32;
        description "Packets in";
      }

      leaf outputs {
        type uint32;
        description "Packets out";
      }

      leaf format-error {
        type uint32;
        description "Malformed packets in";
      }

      leaf pakman-error {
        type uint32;
        description "Pakman packets dropped";
      }

      leaf standby-packets-error {
        type uint32;
        description
          "Packets received in standby state";
      }

      leaf checksum-error {
        type uint32;
        description "Checksum errors";
      }

      leaf socket-error {
        type uint32;
        description "Socket errors";
      }

      leaf send-queue-full {
        type uint32;
        description
          "Packets dropped since send queue was full";
      }

      leaf boundary-acl-rx-drop {
        type uint32;
        description
          "Inc. JP dropped since boundary ACL confg";
      }

      leaf boundary-acl-tx-drop {
        type uint32;
        description
          "Out JP dropped since boundary ACL confg";
      }

      leaf no-socket-connection {
        type uint32;
        description
          "Packets dropped since no socket connection";
      }

      leaf no-source-address {
        type uint32;
        description
          "Packets dropped since no source address";
      }

      leaf input-hello {
        type uint32;
        description "Hello packets in";
      }

      leaf output-hello {
        type uint32;
        description "Hello packets out";
      }

      leaf input-jp {
        type uint32;
        description "Join Prune packets in";
      }

      leaf output-jp {
        type uint32;
        description "Join Prune packets out";
      }

      leaf input-data-register {
        type uint32;
        description
          "Data Register packets in";
      }

      leaf input-null-register {
        type uint32;
        description
          "Null Register packets in";
      }

      leaf output-null-register {
        type uint32;
        description
          "Null Register packets out";
      }

      leaf input-register-stop {
        type uint32;
        description
          "Register Stop packets in";
      }

      leaf output-register-stop {
        type uint32;
        description
          "Register Stop packets out";
      }

      leaf input-assert {
        type uint32;
        description "Assert packets in";
      }

      leaf input-assert-batched {
        type uint32;
        description
          "Batched Assert packets in";
      }

      leaf output-assert {
        type uint32;
        description "Assert packets out";
      }

      leaf output-assert-batched {
        type uint32;
        description
          "Batched Assert packets out";
      }

      leaf input-df-election {
        type uint32;
        description "DF Election packets in";
      }

      leaf output-df-election {
        type uint32;
        description
          "DF Election packets out";
      }

      leaf input-bsr-message {
        type uint32;
        description "Input BSR Messages";
      }

      leaf output-bsr-message {
        type uint32;
        description "Output BSR Messages";
      }

      leaf input-candidate-rp-advertisement {
        type uint32;
        description
          "Input Candidate-RP Advertisment";
      }

      leaf output-candidate-rp-advertisement {
        type uint32;
        description
          "Output Candidate-RP Advertisment";
      }

      leaf input-ecmp-redirect {
        type uint32;
        description "Input Ecmp Redirect";
      }

      leaf output-ecmp-redirect {
        type uint32;
        description "Output Ecmp Redirect";
      }

      leaf output-loop-error {
        type uint32;
        description
          "Output on loopback error";
      }

      leaf mldp-mdt-invalid-lsm-identifier {
        type uint32;
        description " Invalid LSM ID";
      }

      leaf input-no-idb-error {
        type uint32;
        description "No IDB for intf error";
      }

      leaf input-no-vrf-error {
        type uint32;
        description "No VRF for idb error";
      }

      leaf input-no-pim-error {
        type uint32;
        description
          "PIM Disabled on intf error";
      }

      leaf input-pim-version-error {
        type uint32;
        description
          "Invalid PIM version error";
      }

      leaf output-join-group {
        type uint32;
        description "Output Join Groups";
      }

      leaf output-prune-group {
        type uint32;
        description "Output Prune Groups";
      }

      leaf output-join-prune-bytes {
        type uint32;
        units "byte";
        description "Output JP Bytes";
      }

      leaf output-hello-bytes {
        type uint32;
        units "byte";
        description "Output Hello Bytes";
      }

      leaf non-supported-packets {
        type uint32;
        description
          "PIM non supported pckets";
      }

      leaf invalid-registers {
        type uint32;
        description
          "PIM invalid registers received";
      }

      leaf invalid-join-prunes {
        type uint32;
        description
          "PIM invalid Join/Prunes received";
      }

      leaf packet-packman-error {
        type uint32;
        description
          "Packets Dropped due to Pakman Error";
      }

      leaf packet-read-socket-error {
        type uint32;
        description
          "Packet Read Socket Error";
      }

      leaf packet-queue-last-clear {
        type uint32;
        units "second";
        description
          "Time in seconds since the last clear of all
         packet queues stats";
      }

      leaf packets-standby {
        type uint32;
        description
          "Packets Dropped due to Standby Error";
      }

      leaf no-mdt-socket-connection {
        type uint32;
        description
          "Packets dropped since no mdt socket connection";
      }

      leaf mdt-send-queue-full {
        type uint32;
        description
          "Packets dropped since mdt send queue was full";
      }

      leaf mdt-socket-error {
        type uint32;
        description "MDT Socket errors";
      }

      leaf mdt-join-tlv-sent {
        type uint32;
        description
          "Data MDT Join Msgs sent";
      }

      leaf mdt-join-tlv-received {
        type uint32;
        description
          "Data MDT Join Msgs received";
      }

      leaf mdt-join-bad-type {
        type uint32;
        description "Data MDT TLV bad type";
      }

      leaf mdt-drop-local-source-address {
        type uint32;
        description
          "Data MDT Join msgs dropped due to local source
         addr";
      }

      leaf mdt-drop-null-local-address {
        type uint32;
        description
          "Data MDT Join msgs dropped due to null local
         addr";
      }

      leaf mdt-drop-no-idb {
        type uint32;
        description
          "Data MDT Join msgs dropped due to idb missing";
      }

      leaf mdt-drop-no-vrf {
        type uint32;
        description
          "Data MDT Join msgs dropped due to vrf missing";
      }

      leaf invalid-destination-packets {
        type uint32;
        description
          "Control Packets with Invalid Destination";
      }

      leaf mdt-joins-drop-multiple-encapsulation {
        type uint32;
        description
          "MDT Join msgs dropped due to multiple Encap
         limitation";
      }

      leaf truncated-pim-packets {
        type uint32;
        description
          "Packets dropped due to truncated Joins or Prunes";
      }

      leaf invalid-source-encodings {
        type uint32;
        description
          "Number of invalid source encodings received";
      }

      leaf invalid-hello-options {
        type uint32;
        description
          "Number of invalid hello options received";
      }

      list packet-queue {
        max-elements 2;
        description
          "Packet queue state and statistics";
        uses PIM-PKTQ;
      }  // list packet-queue
    }  // grouping PIM-TRAFFIC-BAG

    grouping PIM-GRP-MAP-BAG {
      description
        "PIM group-map basic information";
      container prefix {
        description "Group range prefix";
        uses PIM-ADDRTYPE;
      }  // container prefix

      container rp-address {
        description
          "Rendezvous Point Address";
        uses PIM-ADDRTYPE;
      }  // container rp-address

      leaf prefix-length {
        type int32;
        description
          "Group range prefix length";
      }

      leaf client {
        type Pim-show-range-client;
        description
          "Client mapping learnt from";
      }

      leaf protocol {
        type Pim-show-protocol;
        description
          "Protocol mode of the range";
      }

      leaf group-count {
        type uint32;
        description
          "No. of groups in this range";
      }

      leaf is-used {
        type boolean;
        description
          "Is this mapping being used?";
      }

      leaf mrib-active {
        type boolean;
        description
          "Is this mapping active in MRIB?";
      }

      leaf is-override {
        type boolean;
        description
          "Is this the override range?";
      }

      leaf priority {
        type uint32;
        description "Bootstrap priority";
      }
    }  // grouping PIM-GRP-MAP-BAG

    grouping PIM-GRP-MAP-INFOSRC-BAG {
      description
        "PIM group-map source information";
      container source-of-information {
        description
          "The source of information";
        uses PIM-ADDRTYPE;
      }  // container source-of-information

      container group-map-information {
        description
          "Group Mapping information";
        uses PIM-GRP-MAP-BAG;
      }  // container group-map-information

      leaf holdtime {
        type int32;
        units "second";
        description "Holdtime in seconds";
      }

      leaf expires {
        type uint64;
        units "second";
        description
          "Mapping expiry time in seconds";
      }

      leaf uptime {
        type uint64;
        units "second";
        description
          "Mapping uptime in seconds";
      }
    }  // grouping PIM-GRP-MAP-INFOSRC-BAG

    grouping PIM-TT-OLE-BAG {
      description
        "PIM topology OLE information";
      container assert-winner {
        description "Assert Winner";
        uses PIM-ADDRTYPE;
      }  // container assert-winner

      leaf interface-name {
        type xr:Interface-name;
        description "Interface Identifier";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expiry {
        type uint64;
        units "second";
        description "Expiry in seconds";
      }

      leaf bgp-c-mcast-prune-delay-timer {
        type uint64;
        units "second";
        description
          "BGP C-MCAST Prune Suppression in seconds";
      }

      leaf jp-timer {
        type int32;
        units "second";
        description
          "Join-Prune Timer (secs)";
      }

      leaf jp-state {
        type int32;
        description "Join-Prune State";
      }

      leaf assert-timer {
        type int32;
        units "second";
        description
          "Assert Timer in seconds";
      }

      leaf local-members {
        type int32;
        description
          "Local Information. Deprecated - use
         'local-members-information' instead";
      }

      leaf internal-interest-info {
        type int32;
        description
          "Internal Interest. Deprecated - use
         'internal-interest-information' instead";
      }

      leaf forwarding-state {
        type int32;
        description "Forward or Prune";
      }

      leaf immediate-state {
        type int32;
        description "Immediate fwding state";
      }

      leaf last-hop {
        type boolean;
        description "Are we last hop ?";
      }

      leaf mldp-inband-mdt {
        type boolean;
        description
          "MLDP Inband MDT interface";
      }

      leaf mldp-stale {
        type boolean;
        description "OLE is stale";
      }

      leaf sa-prune {
        type boolean;
        description "BGP SA Prune state";
      }

      leaf admin-boundary {
        type boolean;
        description
          "Is this an administrative boundary ?";
      }

      leaf igmp-membership {
        type boolean;
        description "IGMP membership";
      }

      leaf mdt-safi-join {
        type boolean;
        description "MDT Safi join";
      }

      leaf mvpn-safi-join {
        type boolean;
        description "MVPN Safi join";
      }

      leaf local-mdt-join {
        type boolean;
        description "Default MDT Join";
      }

      leaf data-mdt-join {
        type boolean;
        description "Data MDT join";
      }

      leaf mvpnv6-safi-join {
        type boolean;
        description "MVPN IPv6 Safi join";
      }

      leaf bgp-c-mcast-join {
        type boolean;
        description "BGP C-Mcast join";
      }

      leaf vrf-name {
        type string {
          length "0..33";
        }
        description
          "VRF which physically owns";
      }

      leaf extranet-interface {
        type boolean;
        description
          "Is this an Extranet Interface ?";
      }

      leaf internal-interest-information {
        type Pim-internal-interest-info;
        description
          "Internal Interest. Replaces
         internal-interest-info";
      }

      leaf local-members-information {
        type Pim-show-local-interest;
        description
          "Local Information. Replaces local-members";
      }

      leaf assert-state {
        type boolean;
        description "Assert State";
      }
    }  // grouping PIM-TT-OLE-BAG

    grouping PIM-TT-ROUTE-BAG {
      description "PIM topology table route";
      container group-address-xr {
        description "Group Address";
        uses PIM-ADDRTYPE;
      }  // container group-address-xr

      container source-address-xr {
        description "Source Address";
        uses PIM-ADDRTYPE;
      }  // container source-address-xr

      container rp-address {
        description "RP Address (If rpt)";
        uses PIM-ADDRTYPE;
      }  // container rp-address

      container rpf-neighbor {
        description "RPF Neighbor";
        uses PIM-ADDRTYPE;
      }  // container rpf-neighbor

      container secondary-rpf-neighbor {
        description "Secondary RPF Neighbor";
        uses PIM-ADDRTYPE;
      }  // container secondary-rpf-neighbor

      container rpf-root {
        description
          "Root of this mcast tree";
        uses PIM-ADDRTYPE;
      }  // container rpf-root

      container proxy-address {
        description "RPF Proxy address.";
        uses PIM-ADDRTYPE;
      }  // container proxy-address

      container orig-src-address {
        description "Orig Src Address.";
        uses PIM-ADDRTYPE;
      }  // container orig-src-address

      leaf limit-reached {
        type boolean;
        description
          "Have we throttled the creation of routes or
         interfaces ?";
      }

      leaf low-memory {
        type boolean;
        description
          "Node is running low on memory";
      }

      leaf protocol {
        type Pim-show-protocol;
        description "The PIM protocol";
      }

      leaf wildcard {
        type boolean;
        description "WC -Wildcard";
      }

      leaf rpt-xr {
        type boolean;
        description "Is this on the RPT ?";
      }

      leaf spt {
        type boolean;
        description "Is this on the SPT ?";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expiry {
        type uint64;
        description
          "When this entry expires";
      }

      leaf alive {
        type int32;
        units "second";
        description
          "Alive time in seconds (-1 if never)";
      }

      leaf register-received-timer {
        type int32;
        units "second";
        description
          "Register Received Timer in seconds (-1 if never)";
      }

      leaf remote-source {
        type boolean;
        description "MSDP told us";
      }

      leaf crossed-threshold {
        type boolean;
        description
          "Incoming traffic crossed threshold. MT flag set";
      }

      leaf data-mdt-addr-assigned {
        type boolean;
        description
          "PIM has assigned a Data MDT Address";
      }

      leaf rpf-interface-name {
        type xr:Interface-name;
        description "Interface Identifier";
      }

      leaf rpf-vrf-name {
        type string {
          length "0..33";
        }
        description "RPF VRF Name";
      }

      leaf rpf-safi {
        type uint8;
        description "Unicast or mcast";
      }

      leaf rpf-table-name {
        type string;
        description "RPF Table name";
      }

      leaf rpf-drop {
        type boolean;
        description "RPF route-policy drop";
      }

      leaf rpf-extranet {
        type boolean;
        description
          "Extranet RPF route-policy";
      }

      leaf is-via-lsm {
        type boolean;
        description "Via LSM";
      }

      leaf secondary-rpf-interface-name {
        type xr:Interface-name;
        description
          "Secondary Interface Identifier";
      }

      leaf connected {
        type boolean;
        description "Is Connected ?";
      }

      leaf proxy {
        type boolean;
        description
          "Is the RPF target a proxy?";
      }

      leaf rpf-proxy-enabled {
        type boolean;
        description
          "Is rpf if proxy enabled?";
      }

      leaf mofrr-enabled {
        type boolean;
        description
          "Is this SG MoFRR enabled?";
      }

      leaf rib-mo-frr-enabled {
        type boolean;
        description
          "Is this SG MoFRR enabled?";
      }

      leaf jp-timer {
        type int32;
        description "Join-Prune Timer";
      }

      leaf jp-status {
        type int32;
        description "Join-Prune Status";
      }

      leaf suppress-registers {
        type int32;
        description
          "When the Null register probe expires";
      }

      leaf assume-alive {
        type boolean;
        description "The Assume Alive Bit";
      }

      leaf probe-alive {
        type boolean;
        description "The Probe Alive Bit";
      }

      leaf really-alive {
        type boolean;
        description "The Really Alive Bit";
      }

      leaf inherit-alive {
        type boolean;
        description "The Inherit Alive Bit";
      }

      leaf inherit-spt {
        type boolean;
        description "The Inherit SPT Bit";
      }

      leaf signal-sources {
        type boolean;
        description
          "Signal Sources on route?";
      }

      leaf dont-check-connected {
        type boolean;
        description
          "Do we need to make the connected check on this
         route ?";
      }

      leaf register-received {
        type boolean;
        description
          "Have registers been received for this source ?";
      }

      leaf last-hop {
        type boolean;
        description "Are we last hop ?";
      }

      leaf sending-registers {
        type boolean;
        description
          "Are we sending registers for this route ?";
      }

      leaf sending-null-registers {
        type boolean;
        description
          "Are we sending null registers for this route ?";
      }

      leaf sa-sent {
        type boolean;
        description "BGP SA sent";
      }

      leaf sa-received {
        type boolean;
        description "BGP SA received";
      }

      leaf sa-joined {
        type boolean;
        description "BGP SA join";
      }

      leaf anycast-rp-match {
        type boolean;
        description
          "Group matches Anycast-RP policy";
      }

      leaf anycast-rp-route-target {
        type inet:ipv4-address;
        description "Anycast-RP RT";
      }

      leaf bgp-join {
        type boolean;
        description "BGP C JOIN";
      }

      leaf bgp-jp-time {
        type uint64;
        description "BGP C JP Time";
      }

      leaf customer-routing-type {
        type int32;
        description
          "Type of Customer Routing in the MVPN";
      }

      leaf extranet-route {
        type boolean;
        description "Is a Extranet route ?";
      }

      leaf mofrr-active {
        type boolean;
        description "Is MoFRR Active?";
      }

      leaf mofrr-primary {
        type boolean;
        description "Is this Mofrr Primary?";
      }

      leaf mofrr-backup {
        type boolean;
        description "Is this Mofrr Backup?";
      }

      leaf vxlan {
        type boolean;
        description "Is this VXLAN?";
      }

      leaf kat-state {
        type boolean;
        description "Keep Alive Timer State";
      }

      list outgoing-interface {
        description
          "Outgoing interface list";
        uses PIM-TT-OLE-BAG;
      }  // list outgoing-interface
    }  // grouping PIM-TT-ROUTE-BAG

    grouping PIM-BIDIR-DF-STATE-BAG {
      description
        "PIM Bidirectional DF state";
      container rp-address-xr {
        description "RP Address";
        uses PIM-ADDRTYPE;
      }  // container rp-address-xr

      leaf pim-interface-name {
        type string;
        description "Interface Name";
      }

      leaf election-state {
        type string;
        description "DF Election State";
      }

      leaf time-seconds {
        type uint64;
        units "second";
        description
          "Timer expires (seconds)";
      }

      leaf time-nano-seconds {
        type uint64;
        units "nanosecond";
        description
          "Timer expires (nseconds)";
      }

      leaf our-metric {
        type uint32;
        description "Metric";
      }

      leaf our-metric-preference {
        type uint32;
        description "MetricPreference";
      }
    }  // grouping PIM-BIDIR-DF-STATE-BAG

    grouping PIM-TUNNEL-INFO-BAG {
      description "PIM tunnel information";
      container source-address {
        description
          "Source addr known to PIM";
        uses PIM-ADDRTYPE;
      }  // container source-address

      container rp-address {
        description "RP addr known to PIM";
        uses PIM-ADDRTYPE;
      }  // container rp-address

      container source-address-netio {
        description "Source addr from netio";
        uses PIM-ADDRTYPE;
      }  // container source-address-netio

      container group-address-netio {
        description "Group addr from netio";
        uses PIM-ADDRTYPE;
      }  // container group-address-netio

      leaf vrf-name {
        type string {
          length "0..33";
        }
        description "VRF Name";
      }
    }  // grouping PIM-TUNNEL-INFO-BAG

    grouping PIM-RPF-SUMMARY-BAG {
      description "PIM RPF count summary";
      leaf default-safi {
        type uint32;
        description "Default RPF Table SAFI";
      }

      leaf default-table-name {
        type string;
        description "Default RPF Table Name";
      }

      leaf is-mbgp-configured {
        type boolean;
        description "Is MBGP configured?";
      }

      leaf is-ospf-te-configured {
        type boolean;
        description "Is OSPF TE configured?";
      }

      leaf is-isis-te-configured {
        type boolean;
        description "Is ISIS TE configured?";
      }

      leaf is-isis-mtr-configured {
        type boolean;
        description
          "Is ISIS MTR configured?";
      }

      leaf mo-frr-configured {
        type boolean;
        description "Is MoFRR configured?";
      }

      leaf rib-mo-frr-configured {
        type boolean;
        description
          "Is MoFRR RIB configured?";
      }

      leaf rump-enabled {
        type boolean;
        description "Is RUMP MuRIB enabled?";
      }

      leaf rib-convergence-timeout {
        type uint32;
        units "second";
        description
          "RIB convergence timeout in seconds";
      }

      leaf rib-convergence-time-left {
        type uint32;
        units "second";
        description
          "RIB convergence time left in seconds";
      }

      leaf is-multipath-enabled {
        type boolean;
        description "Is Multipath Enabled ?";
      }

      leaf is-multipath-interface-hash-enabled {
        type boolean;
        description
          "Is Multipath Interface Hash Extension Enabled ?";
      }

      leaf is-multipath-source-hash-enabled {
        type boolean;
        description
          "Is Multipath Source based Hash Enabled ?";
      }

      leaf is-multipath-source-next-hop-hash-enabled {
        type boolean;
        description
          "Is Multipath Source-Nexthop Hash Enabled ?";
      }

      leaf rpf-registrations {
        type uint32;
        description "RPF Registration count";
      }

      leaf is-rib-convergence {
        type boolean;
        description "RIB Convergence status";
      }
    }  // grouping PIM-RPF-SUMMARY-BAG

    grouping PIM-RPF-POLICY-STATS-BAG {
      description
        "PIM RPF policy statistics";
      leaf policy-name {
        type string;
        description "RPF policy name";
      }

      leaf requests {
        type uint32;
        description
          "Number of RPF lookup requests";
      }

      leaf pass {
        type uint32;
        description "Number of RPF pass";
      }

      leaf drop {
        type uint32;
        description "Number of RPF drops";
      }

      leaf default-table {
        type uint32;
        description
          "Number of RPF lookup in default-only Table";
      }

      leaf any-table {
        type uint32;
        description
          "Number of RPF lookup in any Table";
      }
    }  // grouping PIM-RPF-POLICY-STATS-BAG

    grouping PIM-BSR-ELECTION-BAG {
      description "PIM BSR Election State";
      container bsr-address {
        description "BSR address";
        uses PIM-ADDRTYPE;
      }  // container bsr-address

      container candidate-bsr-address {
        description "C-BSR address";
        uses PIM-ADDRTYPE;
      }  // container candidate-bsr-address

      leaf bsr-priority {
        type uint8;
        description "BSR Priority";
      }

      leaf bsr-mask-length {
        type uint8;
        description
          "Hash Function Mask Length";
      }

      leaf bsr-up-time {
        type uint16;
        description "BSR Uptime";
      }

      leaf bootstrap-timeout {
        type uint16;
        description "Bootstrap Timeout";
      }

      leaf candidate-bsr-state {
        type uint32;
        description "BSR Candidate State";
      }

      leaf bsr-election-state {
        type uint32;
        description "BSR Election State";
      }

      leaf bsr-scope {
        type uint16;
        description "BSR Scope";
      }

      leaf candidate-bsr-flag {
        type boolean;
        description
          "BSR Candidate Config Flag";
      }

      leaf candidate-bsr-priority {
        type uint8;
        description "C-BSR Priority";
      }

      leaf candidate-bsr-mask-length {
        type uint8;
        description
          "C-BSR Hash Func. Mask Len";
      }
    }  // grouping PIM-BSR-ELECTION-BAG

    grouping PIM-BSR-CRP-ACL-BAG {
      description
        "PIM BSR Candidate RP Access-list";
      leaf candidate-rp-mode {
        type Pim-show-protocol;
        description "Cand-RP Mode";
      }

      leaf acl-name {
        type string {
          length "0..33";
        }
        description "Group Access-List Name";
      }
    }  // grouping PIM-BSR-CRP-ACL-BAG

    grouping PIM-BSR-CANDIDATE-RP-BAG {
      description "PIM BSR Candidate RP";
      container candidate-rp {
        description "Cand-RP Address";
        uses PIM-ADDRTYPE;
      }  // container candidate-rp

      leaf candidate-rp-mode {
        type Pim-show-protocol;
        description "Cand-RP Mode";
      }

      leaf candidate-rp-scope {
        type int32;
        description "Cand-RP Scope";
      }

      leaf crp-priority {
        type uint8;
        description "Cand-RP Priority";
      }

      leaf crp-holdtime {
        type uint16;
        description "Cand-RP Holdtime";
      }

      leaf candidate-rp-advance-interval {
        type uint16;
        units "second";
        description
          "Cand-RP Adv Interval in seconds";
      }

      leaf candidate-rp-uptime {
        type uint16;
        description "Cand-RP uptime";
      }

      leaf acl-name {
        type string {
          length "0..33";
        }
        description "Group Access-List Name";
      }

      list crp-access {
        max-elements 2;
        description
          "Group Ranges Using this Cand-RP";
        uses PIM-BSR-CRP-ACL-BAG;
      }  // list crp-access
    }  // grouping PIM-BSR-CANDIDATE-RP-BAG

    grouping PIM-BSR-CRP-BAG {
      description "PIM BSR C-RP";
      list pim-bsr-crp-bag {
        description "Next C-RP in the List";
        container candidate-rp-address {
          description "C-RP address";
          uses PIM-ADDRTYPE;
        }  // container candidate-rp-address

        leaf candidate-rp-holdtime {
          type uint16;
          description "C-RP Holdtime";
        }

        leaf candidate-rp-priority {
          type uint8;
          description "C-RP Priority";
        }

        leaf candidate-rp-up-time {
          type uint16;
          description "C-RP Uptime";
        }

        leaf candidate-rp-expires {
          type uint16;
          description "C-RP Expires";
        }

        leaf protocol {
          type Pim-show-protocol;
          description "PIM Protocol";
        }
      }  // list pim-bsr-crp-bag
    }  // grouping PIM-BSR-CRP-BAG

    grouping PIM-BSR-RP-CACHE-BAG {
      description "PIM BSR RP cache";
      container group-prefix-xr {
        description "Group Prefix";
        uses PIM-ADDRTYPE;
      }  // container group-prefix-xr

      container candidate-rp-list {
        description
          "C-RP list for this prefix";
        uses PIM-BSR-CRP-BAG;
      }  // container candidate-rp-list

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

      leaf candidate-rp-group-count {
        type uint32;
        description
          "C-RP count for this Prefix";
      }
    }  // grouping PIM-BSR-RP-CACHE-BAG

    grouping PIM-RL-RP-RANGE-BAG {
      description
        "PIM RP range list information";
      container prefix {
        description "Group range prefix";
        uses PIM-ADDRTYPE;
      }  // container prefix

      container source-of-information {
        description "Source of information";
        uses PIM-ADDRTYPE;
      }  // container source-of-information

      leaf prefix-length {
        type int32;
        description
          "Group range prefix length";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expires {
        type uint64;
        description "When mapping expires";
      }
    }  // grouping PIM-RL-RP-RANGE-BAG

    grouping PIM-RL-BAG {
      description
        "PIM range list information";
      container rp-address-xr {
        description
          "Rendezvous point address";
        uses PIM-ADDRTYPE;
      }  // container rp-address-xr

      container source-of-information {
        description "Source of information";
        uses PIM-ADDRTYPE;
      }  // container source-of-information

      leaf protocol {
        type Pim-show-protocol;
        description "PIM protocol";
      }

      leaf client-xr {
        type Pim-show-range-client;
        description
          "Client mapping learnt via";
      }

      leaf expires {
        type uint64;
        description "When mapping expires";
      }

      list group-range {
        description "List of group ranges";
        uses PIM-RL-RP-RANGE-BAG;
      }  // list group-range
    }  // grouping PIM-RL-BAG

    grouping PIM-IDB-SUMM-BAG {
      description
        "PIM IFRS interface summary";
      leaf interface-count {
        type uint32;
        description "Number of interfaces";
      }

      leaf configuration-count {
        type uint32;
        description "Configuration counts";
      }
    }  // grouping PIM-IDB-SUMM-BAG

    grouping PIM-MROUTE-BAG {
      description
        "Multicast Route MIB entry";
      container source-address-xr {
        description "Source Address";
        uses PIM-ADDRTYPE;
      }  // container source-address-xr

      container group-address-xr {
        description "Group Address";
        uses PIM-ADDRTYPE;
      }  // container group-address-xr

      container rpf-neighbor {
        description "The RPF Neighbor";
        uses PIM-ADDRTYPE;
      }  // container rpf-neighbor

      container rpf-root {
        description
          "Root of this mcast tree";
        uses PIM-ADDRTYPE;
      }  // container rpf-root

      leaf upstream-assert-timer {
        type int32;
        description "Upstream Assert Timer";
      }

      leaf assert-metric {
        type uint32;
        description "Assert Metric";
      }

      leaf assert-metric-preference {
        type uint32;
        description
          "Assert Metric Preference";
      }

      leaf assert-rpt-bit {
        type boolean;
        description "Assert RPT Bit";
      }

      leaf spt-bit {
        type boolean;
        description "Is SPT bit set ?";
      }

      leaf rpf-mask {
        type uint32;
        description
          "Mask of the multicast root";
      }

      leaf rpf-safi {
        type uint8;
        description "Unicast or mcast";
      }

      leaf rpf-table-name {
        type string;
        description "RPF Table name";
      }

      leaf rpf-drop {
        type boolean;
        description "RPF route-policy drop";
      }

      leaf rpf-extranet {
        type boolean;
        description
          "Extranet RPF route-policy";
      }

      leaf rpf-interface-name {
        type xr:Interface-name;
        description "RPF interface name ";
      }

      leaf rpf-vrf-name {
        type string {
          length "0..33";
        }
        description "RPF VRF Name";
      }

      leaf bidirectional-route {
        type boolean;
        description "Is this Bidir ?";
      }

      leaf uptime {
        type uint64;
        description "Uptime of route";
      }

      leaf protocol {
        type Pim-show-protocol;
        description "The PIM protocol";
      }
    }  // grouping PIM-MROUTE-BAG

    grouping PIM-JPSTATS-BAG {
      description "PIM join-prune statistic";
      leaf interface-name-xr {
        type xr:Interface-name;
        description "Interface Identifier";
      }

      leaf mtu {
        type uint32;
        description "Interface MTU";
      }

      leaf transmitted {
        type uint32;
        description "Transmitted";
      }

      leaf transmitted100 {
        type uint16;
        description
          "Transmitted 100 average";
      }

      leaf transmitted-1k {
        type uint16;
        description "Transmitted 1K average";
      }

      leaf transmitted-10k {
        type uint16;
        description
          "Transmitted 10K average";
      }

      leaf transmitted-50k {
        type uint16;
        description
          "Deprecated by Transmitted100";
      }

      leaf received {
        type uint32;
        description "Received";
      }

      leaf received100 {
        type uint16;
        description "Received 100 average";
      }

      leaf received-1k {
        type uint16;
        description "Received 1K average";
      }

      leaf received-10k {
        type uint16;
        description "Received 10K average";
      }

      leaf received-50k {
        type uint16;
        description
          "Deprecated by Received100";
      }
    }  // grouping PIM-JPSTATS-BAG

    grouping PIM-TT-SUMM-BAG {
      description
        "PIM topology table summary";
      leaf group-ranges {
        type uint32;
        description "No. of (*,G/M) routes";
      }

      leaf active-group-ranges {
        type uint32;
        description
          "No. of (*,G/M) routes active in mrib";
      }

      leaf groute-count {
        type uint32;
        description "No. of (*,G) routes";
      }

      leaf sg-route-count {
        type uint32;
        description "No. of (S,G) routes";
      }

      leaf sgr-route-count {
        type uint32;
        description "No. of (S,G)RPT routes";
      }

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

    grouping PIM-IFSTATS-BAG {
      description "PIM Interface Statistics";
      leaf input-hello {
        type uint32;
        description "Hello packets in";
      }

      leaf output-hello {
        type uint32;
        description "Hello packets out";
      }

      leaf input-register {
        type uint32;
        description "Register packets in";
      }

      leaf output-register {
        type uint32;
        description "Register packets out";
      }

      leaf input-register-stop {
        type uint32;
        description
          "Register Stop packets in";
      }

      leaf output-register-stop {
        type uint32;
        description
          "Register Stop packets out";
      }

      leaf input-jp {
        type uint32;
        description "Join Prune packets in";
      }

      leaf output-jp {
        type uint32;
        description "Join Prune packets out";
      }

      leaf input-bsr-message {
        type uint32;
        description "Input BSR Messages";
      }

      leaf output-bsr-message {
        type uint32;
        description "Output BSR Messages";
      }

      leaf input-assert {
        type uint32;
        description "Assert packets in";
      }

      leaf output-assert {
        type uint32;
        description "Assert packets out";
      }

      leaf input-graft-message {
        type uint32;
        description "Input Graft Messages";
      }

      leaf output-graft-message {
        type uint32;
        description "Output Graft Messages";
      }

      leaf input-graft-ack-message {
        type uint32;
        description
          "Input Graft Ack Messages";
      }

      leaf output-graft-ack-message {
        type uint32;
        description
          "Output Graft Ack Messages";
      }

      leaf input-candidate-rp-advertisement {
        type uint32;
        description
          "Input Candidate-RP Advertisment";
      }

      leaf output-candidate-rp-advertisement {
        type uint32;
        description
          "Output Candidate-RP Advertisment";
      }

      leaf input-df-election {
        type uint32;
        description "DF Election packets in";
      }

      leaf output-df-election {
        type uint32;
        description
          "DF Election packets out";
      }

      leaf input-miscellaneous {
        type uint32;
        description
          "Miscellaneous packet in";
      }
    }  // grouping PIM-IFSTATS-BAG

    grouping PIM-IDB-BAG {
      description "PIM interface";
      container dr-address {
        description "PIM Designated Router";
        uses PIM-ADDRTYPE;
      }  // container dr-address

      leaf interface-name-xr {
        type xr:Interface-name;
        description "Interface Identfier";
      }

      leaf interface-address-mask {
        type uint8;
        description
          "Interface IP Address Mask";
      }

      leaf is-enabled {
        type boolean;
        description
          "Is PIM enabled on this IF ?";
      }

      leaf neighbor-count {
        type uint16;
        description
          "No. of neighbors on this IF";
      }

      leaf external-neighbor-count {
        type uint16;
        description
          "No. of external neighbors on this IF";
      }

      leaf hello-interval {
        type uint16;
        description "Hello Interval";
      }

      leaf dr-priority {
        type uint32;
        description "DR Priority";
      }

      leaf hello-expiry {
        type uint64;
        description "Hello Timer Expiry";
      }

      leaf are-we-dr {
        type boolean;
        description
          "Are we the DR on this IF ?";
      }

      leaf bfd-enabled {
        type boolean;
        description "BFD state";
      }

      leaf bfd-interval {
        type uint32;
        description "BFD Interval";
      }

      leaf bfd-multiplier {
        type uint32;
        description "BFD Multiplier";
      }

      leaf virtual-interface {
        type boolean;
        description
          " is this a Virtual Interfaces ?";
      }

      leaf passive-interface {
        type boolean;
        description "Passive PIM interface";
      }

      leaf neighbor-filter-name {
        type string;
        description "Neighbor Filter Name";
      }

      leaf sticky-dr-enabled {
        type boolean;
        description
          "Is Sticky DR enabled on Interface";
      }

      leaf sticky-dr-active {
        type boolean;
        description
          "Is Sticky DR Active on Interface";
      }

      leaf sticky-dr-active-since {
        type uint64;
        units "second";
        description
          "Sticky DR uptime in seconds";
      }

      leaf join-prune-interval {
        type uint16;
        description "Join-Prune Interval";
      }

      leaf prune-delay-enabled {
        type boolean;
        description "Prune Delay Enabled";
      }

      leaf configured-propagation-delay {
        type uint16;
        description
          "Configured Propagation Delay";
      }

      leaf propagation-delay {
        type uint16;
        description "Propagation Delay";
      }

      leaf configured-override-interval {
        type uint16;
        description
          "Configured Override Interval";
      }

      leaf override-interval {
        type uint16;
        description "Override Interval";
      }

      leaf generation-id {
        type uint32;
        description "Generation Identifier";
      }

      leaf is-bidirectional-capable {
        type boolean;
        description "Bidir Capable";
      }

      leaf is-proxy-capable {
        type boolean;
        description "Proxy Capable";
      }

      leaf is-batch-asserts-capable {
        type boolean;
        description "Batch Asserts Capable";
      }

      leaf idb-oor-enabled {
        type boolean;
        description "Interface oor enabled";
      }

      leaf idb-acl-provided {
        type boolean;
        description "ACL name provided";
      }

      leaf idb-max-count {
        type uint32;
        description
          "Interface ole max count";
      }

      leaf idb-threshold-count {
        type uint32;
        description
          "Interface ole threshold count";
      }

      leaf idb-current-count {
        type uint32;
        description
          "Interface ole current count";
      }

      leaf idb-acl-name {
        type string {
          length "0..64";
        }
        description "Interface ole ACL Name";
      }

      list interface-address {
        description
          "List of Interface IP Addresses";
        uses PIM-ADDRTYPE;
      }  // list interface-address
    }  // grouping PIM-IDB-BAG
  }  // submodule Cisco-IOS-XR-pim-oper-sub1