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

    yang-version 1;

    belongs-to Cisco-IOS-XR-mvpn-oper {
        prefix Cisco-IOS-XR-mvpn-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;
    }

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

    revision "2020-04-02" {
      description
        "MVPN TreeSID information added.";
    }

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

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

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

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

    typedef Pim-seg-leaf-entry {
      type enumeration {
        enum "i-pmsi" {
          value 1;
          description "Intra AS I-PMSI";
        }
        enum "inter-as-i-pmsi" {
          value 2;
          description "Inter AS I-PMSI";
        }
        enum "s-pmsi" {
          value 3;
          description "S PMSI";
        }
        enum "unsolicited-leaf-ad" {
          value 4;
          description "Unsolicited Leaf AD";
        }
        enum "unspecified-leaf-ad" {
          value 6;
          description "Unspecified Leaf AD";
        }
      }
      description "Pim seg leaf entry";
    }

    typedef Pim-seg-entry {
      type enumeration {
        enum "i-pmsi" {
          value 1;
          description "Intra AS I-PMSI";
        }
        enum "s-pmsi" {
          value 3;
          description "S PMSI";
        }
        enum "lib-mvpn-csc" {
          value 8;
          description "PIM LIB MVPN CSC";
        }
      }
      description "Pim seg entry";
    }

    typedef Pim-mgmt-mvpn-id {
      type enumeration {
        enum
          "pim-mgmt-mvpn-id-type-mldp-part-mp2mp" {
          value 0;
          description
            "MLDP Partitioned Multipoint-to-Multipoint";
        }
        enum
          "pim-mgmt-mvpn-id-type-mldp-part-p2mp" {
          value 1;
          description
            "MLDP Partitioned Point-to-Multipoint";
        }
        enum
          "pim-mgmt-mvpn-id-type-mldp-data-mdt" {
          value 2;
          description "MLDP Data MDT";
        }
        enum
          "pim-mgmt-mvpn-id-type-mldp-ctrl" {
          value 3;
          description "MLDP Control";
        }
        enum
          "pim-mgmt-mvpn-id-type-mldp-part-bidir-mp2mp" {
          value 4;
          description
            "MLDP Partitioned Bidirectional
           Multipoint-to-Multipoint";
        }
        enum
          "pim-mgmt-mvpn-id-type-mldp-def" {
          value 5;
          description "MLDP Default";
        }
        enum "p2mp-rsvp-te-default" {
          value 6;
          description "RSVP TE Default";
        }
        enum "p2mp-rsvp-te-partitioned" {
          value 7;
          description "RSVP TE Partitioned";
        }
        enum "p2mp-rsvp-te-data-mdt" {
          value 8;
          description "RSVP TE Data MDT";
        }
        enum "ingress-replication-default" {
          value 9;
          description "IR Default";
        }
        enum
          "ingress-replication-partitioned" {
          value 10;
          description "IR Partitioned";
        }
        enum "ingress-replication-data-mdt" {
          value 11;
          description "IR Data MDT";
        }
        enum "ingress-replication-control" {
          value 12;
          description "IR Control";
        }
        enum "segment-mdt" {
          value 13;
          description "Segment MDT";
        }
      }
      description "MVPN ID type";
    }

    typedef Pim-bag-mdt {
      type enumeration {
        enum "in-band" {
          value 0;
          description "Inband type MDT";
        }
        enum "gre" {
          value 1;
          description "GRE type MDT";
        }
        enum "mldp" {
          value 2;
          description "MLDP type MDT";
        }
        enum "p2mp" {
          value 3;
          description "P2MP type MDT";
        }
        enum "ir" {
          value 4;
          description "IR type MDT";
        }
        enum "vxlan" {
          value 5;
          description "VXLAN type MDT";
        }
        enum "gin-band" {
          value 6;
          description "GInband type MDT";
        }
        enum "tree-sid" {
          value 7;
          description "Tree-SID type MDT";
        }
      }
      description "MDT type";
    }

    typedef Pim-bag-mldp-opaque {
      type enumeration {
        enum "opaque-global-identifier" {
          value 1;
          description
            "Global-ID Opaque Type";
        }
        enum "opaque-vpn-identifier" {
          value 2;
          description "VPN-ID Opaque Type";
        }
      }
      description "MLDP Opaque type";
    }

    typedef Pim-bag-mldp-tree {
      type enumeration {
        enum "p2m-ptree" {
          value 6;
          description "MLDP P2MP Tree";
        }
        enum "mp2m-ptree" {
          value 8;
          description "MLDP MP2MP Tree";
        }
      }
      description "MLDP Tree type";
    }

    typedef Ipv6-address {
      type inet:ipv6-address;
      description "IPV6 Address type";
    }

    typedef Pim-afi {
      type enumeration {
        enum "ipv4-unicast" {
          value 0;
          description "IP v4 unicast";
        }
        enum "ipv6-unicast" {
          value 1;
          description "IP v6 unicast";
        }
      }
      description "Address family";
    }

    grouping PIM-TIMESPEC-BAG {
      description "PIM timespec bag";
      leaf seconds {
        type uint32;
        units "second";
        description
          "Seconds part of time value";
      }

      leaf nanoseconds {
        type uint32;
        units "nanosecond";
        description
          "Nanoseconds part of time value";
      }
    }  // grouping PIM-TIMESPEC-BAG

    grouping PIM-LEAF-AD-BAG {
      description "PIM Leaf AD information";
      container leg-created {
        description
          "Outgoing leg creation time";
        uses PIM-TIMESPEC-BAG;
      }  // container leg-created

      leaf originating-router {
        type inet:ipv4-address;
        description "Originating Router";
      }

      leaf label {
        type uint32;
        description "MPLS Label";
      }

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

    grouping PIM-SEGMENT-DB-BAG {
      description
        "Segment database information";
      container source-address {
        description "Source Address";
        uses PIM-ADDRTYPE;
      }  // container source-address

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

      container upstream-core-context {
        description "Upstream Core Context";
        uses PIM-DATAMDT-CORETYPE;
      }  // container upstream-core-context

      container downstream-core-context {
        description
          "Downstream Core Context";
        uses PIM-DATAMDT-CORETYPE;
      }  // container downstream-core-context

      container old-upstream-core-context {
        description
          "Old Upstream Core Context";
        uses PIM-DATAMDT-CORETYPE;
      }  // container old-upstream-core-context

      container segment-created {
        description
          "Segment entry creation time";
        uses PIM-TIMESPEC-BAG;
      }  // container segment-created

      container spmsi-rx {
        description
          "SPMSI entry creation time";
        uses PIM-TIMESPEC-BAG;
      }  // container spmsi-rx

      container spmsi-sent {
        description "SPMSI sent time";
        uses PIM-TIMESPEC-BAG;
      }  // container spmsi-sent

      leaf segmented-entry-type {
        type Pim-seg-entry;
        description "Segmented Entry Type";
      }

      leaf segmented-entry-leaf-type {
        type Pim-seg-leaf-entry;
        description
          "Segmented Entry Leaf Type";
      }

      leaf source-address-length {
        type uint32;
        description "Source Address Length";
      }

      leaf group-address-length {
        type uint32;
        description "Group Address Length";
      }

      leaf pe-address {
        type inet:ipv4-address;
        description "PE Address";
      }

      leaf tree-type {
        type uint8;
        description "Tree Type";
      }

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

      leaf fec-opaque-type {
        type uint8;
        description "FEC Opaque Type";
      }

      leaf fec-opaque-length {
        type uint16;
        description "FEC Opaque Length";
      }

      leaf fec-opaque-value {
        type yang:hex-string;
        description "FEC Opaque Value";
      }

      leaf rpf-neighbor {
        type inet:ipv4-address;
        description "RPF Neighbor Address";
      }

      leaf old-rpf-neighbor {
        type inet:ipv4-address;
        description
          "Previous RPF Neighbor Address";
      }

      leaf chkpt-object-identifier {
        type uint32;
        description "Checkpoint Object ID";
      }

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

      leaf entry-type {
        type uint8;
        description "Segmented Entry Type";
      }

      leaf segmented-id {
        type uint32;
        description "Segmented ID";
      }

      leaf old-segmented-id {
        type uint32;
        description "Old Segmented ID";
      }

      leaf is-s-pmsi-originated {
        type boolean;
        description "Is S PMSI Originated";
      }

      leaf is-s-pmsi-sent {
        type boolean;
        description "Is S PMSI sent";
      }

      leaf is-i-pmsi-sent {
        type boolean;
        description "Is I PMSI sent";
      }

      leaf is-s-pmsi-received {
        type boolean;
        description "Is S PMSI Received";
      }

      leaf is-i-pmsi-received {
        type boolean;
        description "Is I PMSI Received";
      }

      leaf is-unsol-leaf-ad-sent {
        type boolean;
        description
          "Is Unsolicited Leaf AD sent";
      }

      leaf is-leaf-ad-sent {
        type boolean;
        description "Is Leaf AD sent";
      }

      leaf is-upstream-tree-added {
        type boolean;
        description "Is Upstream Tree added";
      }

      leaf is-downstream-tree-added {
        type boolean;
        description
          "Is Downstream Tree added";
      }

      leaf downstream-core-type {
        type boolean;
        description
          "Downstream Core Tree Type";
      }

      leaf upstream-core-type {
        type boolean;
        description
          "UpStream Core Tree Type";
      }

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

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

      leaf stale {
        type boolean;
        description "Stale";
      }

      list lead-ad {
        description "Leaf AD list";
        uses PIM-LEAF-AD-BAG;
      }  // list lead-ad
    }  // grouping PIM-SEGMENT-DB-BAG

    grouping PIM-MVPN-ID-INFO {
      description "MVPN ID information";
      leaf mvpn-identifier-xr {
        type uint32;
        description "MVPN ID";
      }

      leaf mvpn-identifier-type {
        type Pim-mgmt-mvpn-id;
        description "MVPN ID type";
      }

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

      leaf stale {
        type boolean;
        description
          "TRUE if MVPN ID is stale";
      }

      leaf chkpt-object-identifier {
        type uint32;
        description "Checkpoint Object ID";
      }
    }  // grouping PIM-MVPN-ID-INFO

    grouping PIM-MDT-DATA-TREESID-BAG {
      description "PIM Tree-SID bag";
      container mdt-data-core-tree-sid {
        description "Data MDT Tree-SID core";
        uses PIM-TREESID-CORE;
      }  // container mdt-data-core-tree-sid

      container mdt-data-source {
        description "Data MDT Source";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-source

      leaf is-mdt-delete-in-progress {
        type boolean;
        description
          "Is the entry being deleted ?";
      }

      leaf is-mdt-local {
        type boolean;
        description
          "Is the entry locally assigned ?";
      }

      leaf mdt-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix";
      }

      leaf mdt-decapsulation-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix on Decap
         PE";
      }

      leaf on-demand-color {
        type uint32;
        description "On-Demand Color";
      }

      leaf lfa-protected {
        type boolean;
        description
          "Is the entry Tree-SID protected by LFA FRR?";
      }

      list receiver-pe {
        description "Receiver PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list receiver-pe
    }  // grouping PIM-MDT-DATA-TREESID-BAG

    grouping PIM-MDT-DATA-PFX-BAG {
      description "PIM Data MDT prefix bag";
      container mdt-data-prefix {
        description "Data MDT Prefix";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-prefix

      container mdt-data-source {
        description "Data MDT Source";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-source

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

      leaf is-mdt-delete-in-progress {
        type boolean;
        description
          "Is the entry being deleted ?";
      }

      leaf is-mdt-local {
        type boolean;
        description
          "Is the entry locally assigned ?";
      }

      leaf mdt-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix";
      }

      leaf mdt-decapsulation-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix on Decap
         PE";
      }
    }  // grouping PIM-MDT-DATA-PFX-BAG

    grouping PIM-BGP-SAFI-BAG {
      description "PIM BGP SAFI bag";
      container source {
        description "Source address";
        uses PIM-ADDRTYPE;
      }  // container source

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

      container next-hop {
        description "Next hop address";
        uses PIM-ADDRTYPE;
      }  // container next-hop

      leaf route-distinguisher {
        type string {
          length "0..256";
        }
        description "Router ID";
      }

      leaf extranet-path-count {
        type uint32;
        description
          "Count of dependent extranet paths";
      }

      leaf is-bgp-added {
        type boolean;
        description "SAFI learnt from BGP";
      }
    }  // grouping PIM-BGP-SAFI-BAG

    grouping PIM-PE-BAG {
      description "PIM MVPN PE";
      leaf ppmp-label {
        type uint32;
        description "PPMP Label";
      }

      leaf mvpn-identifier {
        type uint32;
        description "MVPN ID";
      }

      leaf ms-pmsi-head-lsm-identifier {
        type uint32;
        description
          "MS PMSI Head LSM Identifier";
      }

      leaf bidir-pmsi-head-lsm-identifier {
        type uint32;
        description
          "Bidir PMSI Head LSM Identifier";
      }

      leaf s-pmsi-count {
        type uint32;
        description "S PMSI Count";
      }

      leaf bidir-pmsi {
        type string {
          length "0..70";
        }
        description "Bidir PMSI String";
      }

      leaf remote-bidir-pmsi {
        type string {
          length "0..70";
        }
        description
          "Remote Bidir PMSI String";
      }

      leaf i-pmsi {
        type string {
          length "0..70";
        }
        description "I PMSI String";
      }

      leaf i-pmsi-v6 {
        type string {
          length "0..70";
        }
        description "I PMSI v6 String";
      }

      leaf ms-pmsi {
        type string {
          length "0..70";
        }
        description "MS PMSI String";
      }

      leaf bsr-pmsi {
        type string {
          length "0..70";
        }
        description "BSR PMSI";
      }

      leaf auto-rp-discovery-pmsi {
        type string {
          length "0..70";
        }
        description "AutoRP Discovery PMSI";
      }

      leaf auto-rp-announce-pmsi {
        type string {
          length "0..70";
        }
        description "AutoRP Announce PMSI";
      }

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

      leaf ms-pmsi-state {
        type uint32;
        description "MS PMSI State";
      }

      leaf rib-head-lsm-identifier {
        type uint32;
        description "RIB Head LSM ID";
      }

      leaf shared-count {
        type uint32;
        description
          "Shared Count to this Ingress PE";
      }

      leaf source-count {
        type uint32;
        description
          "Source count to this Ingress PE";
      }

      leaf dm-source-count {
        type uint32;
        description
          "DM Source count to this Ingress PE";
      }

      leaf def-md-source-count {
        type uint32;
        description
          "Def MD Source count to this Ingress PE";
      }

      leaf srp2m-policy-count {
        type uint32;
        description
          "SR P2MP Policy count to this Ingress PE";
      }

      leaf gre-bidir-rp-count {
        type uint32;
        description
          "GRE Bidir RP count to this Ingress PE";
      }

      leaf mpls-bidir-rp-count {
        type uint32;
        description
          "MPLS Bidir RP count to this Ingress PE";
      }

      leaf number-of-sources {
        type uint32;
        description "Source Count";
      }

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

      leaf number-of-bidir-rp {
        type uint32;
        description "Bidir RP Count";
      }

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

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

      leaf bidir-rpf-identifier {
        type uint32;
        description "Bidir RPF ID";
      }

      leaf remote-bidir-rpf-identifier {
        type uint32;
        description "Remote Bidir RPF ID";
      }

      leaf checkpoint-object-identifier {
        type uint32;
        description "Checkpoint Object ID";
      }

      leaf mvpn-label {
        type uint32;
        description "IR MVPN Tail Label";
      }

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

      leaf tail-identifier-tree-added {
        type boolean;
        description "Tail ID tree added";
      }

      leaf bidir-tail-identifier-tree-added {
        type boolean;
        description
          "Bidir Tail ID Tree Added";
      }

      leaf remote-bidir-tail-identifier-tree-added {
        type boolean;
        description
          "Remote Bidir Tail ID Tree added";
      }

      leaf tail-rd-tree-added {
        type boolean;
        description "Tail RD tree added";
      }

      leaf tail-part-rsvpte-added {
        type boolean;
        description
          "Tail Part RSVP TE added";
      }

      leaf tail-def-rsvpte-added {
        type boolean;
        description "Tail Def RSVP TE added";
      }

      leaf te-leg-added {
        type boolean;
        description "TE Leg Added";
      }

      leaf head-te-ctrl-leg-added {
        type boolean;
        description
          "Head RSVP TE Ctrl Leg added";
      }

      leaf tail-part-ir-added {
        type boolean;
        description "Tail Part IR added";
      }

      leaf head-ir-def-leg-added {
        type boolean;
        description "Head IR Def Leg Added";
      }

      leaf head-ir-ctrl-leg-added {
        type boolean;
        description "Head IR Ctrl Leg added";
      }

      leaf head-ir-part-leg-added {
        type boolean;
        description "Head IR Part Leg added";
      }

      leaf tree-sid-leaf-added {
        type boolean;
        description
          "Tree-SID Default/Partition Leaf Added";
      }

      leaf tree-sid-default-egress-added {
        type boolean;
        description
          "Tree-SID Default Egress Added";
      }

      leaf tree-sid-partition-egress-added {
        type boolean;
        description
          "Tree-SID Partition Egress Added";
      }

      leaf tree-sid-ctrl-leaf-added {
        type boolean;
        description
          "Tree-SID Ctrl Leaf added";
      }

      leaf bgp-bidir-pmsi {
        type boolean;
        description "BGP Bidir PMSI";
      }

      leaf remote-bgp-bidir-pmsi {
        type boolean;
        description "Remote BGP Bidir PMSI";
      }

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

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

      leaf i-pmsi-leaf-ad {
        type boolean;
        description "I PMSI LEAF AD";
      }

      leaf bgp-ms-pmsi {
        type boolean;
        description "BGP MS PMSI";
      }

      leaf ms-pmsi-leaf-ad {
        type boolean;
        description "MS PMSI LEAF AD";
      }

      leaf ctrl-bsr-leaf-ad {
        type boolean;
        description "CTRL BSR LEAF AD";
      }

      leaf ctrl-auto-rp-ann-leaf-ad {
        type boolean;
        description
          "CTRL AUTO RP ANN LEAF AD";
      }

      leaf ctrl-auto-rp-disc-leaf-ad {
        type boolean;
        description
          "CTRL AUTO RP DISC LEAF AD";
      }
    }  // grouping PIM-PE-BAG

    grouping PIM-RELAY-BAG {
      description "PIM Relay";
      leaf relay-vrf-name {
        type string {
          length "0..33";
        }
        description "Relay VRF name";
      }

      leaf pass-through {
        type boolean;
        description "Relay Mode";
      }
    }  // grouping PIM-RELAY-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-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-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-MDT-DATA-IR-BAG {
      description "PIM IR bag";
      container mdt-data-core-ir {
        description "Data MDT IR core";
        uses PIM-IR-CORE;
      }  // container mdt-data-core-ir

      container mdt-data-source {
        description "Data MDT Source";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-source

      leaf is-mdt-delete-in-progress {
        type boolean;
        description
          "Is the entry being deleted ?";
      }

      leaf is-mdt-local {
        type boolean;
        description
          "Is the entry locally assigned ?";
      }

      leaf mdt-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix";
      }

      leaf mdt-decapsulation-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix on Decap
         PE";
      }

      leaf local-label {
        type uint32;
        description "Local Label";
      }

      list receiver-pe {
        description "Receiver PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list receiver-pe
    }  // grouping PIM-MDT-DATA-IR-BAG

    grouping PIM-P2MPTE-CORE {
      description "PIM - P2MPTE core";
      leaf tunnel-type {
        type uint32;
        description "Tunnel Type";
      }

      leaf tunnel-id {
        type uint32;
        description "Tunnel Identifier";
      }

      leaf extended-tunnel-id {
        type inet:ipv4-address;
        description "Extended Tunnel ID";
      }

      leaf core-id {
        type uint32;
        description "Core ID";
      }

      leaf if-handle {
        type uint32;
        description "Interface Handle";
      }

      leaf tunnel-state {
        type boolean;
        description "Tunnel State";
      }
    }  // grouping PIM-P2MPTE-CORE

    grouping PIM-P2MPTE-MDT-TUNNEL-DB-BAG {
      description
        "PIM P2MP-TE MDT TUNNEL DB bag";
      container mdt-default-p2mpte-core {
        description
          "Default MDT P2MPTE core";
        uses PIM-P2MPTE-CORE;
      }  // container mdt-default-p2mpte-core

      container default-mdt-source {
        description "Default MDT Source";
        uses PIM-ADDRTYPE;
      }  // container default-mdt-source

      container mdt-partition-p2mpte-core {
        description
          "Partitioned MDT P2MPTE core";
        uses PIM-P2MPTE-CORE;
      }  // container mdt-partition-p2mpte-core

      container part-mdt-source {
        description "Partitioned MDT Source";
        uses PIM-ADDRTYPE;
      }  // container part-mdt-source

      container mdt-control-p2mpte-core {
        description "Cntrl IR core";
        uses PIM-P2MPTE-CORE;
      }  // container mdt-control-p2mpte-core

      leaf ctrl-tree-type {
        type uint32;
        description "Ctrl Tree Type";
      }

      leaf mdt-type {
        type uint32;
        description "MDT Type";
      }

      list def-pe {
        description "Default MDT PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list def-pe

      list part-pe {
        description
          "Partitioned MDT PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list part-pe

      list ctrl-pe {
        description "Ctrl PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list ctrl-pe
    }  // grouping PIM-P2MPTE-MDT-TUNNEL-DB-BAG

    grouping PIM-MDT-CACHE-LEAF-AD-BAG {
      description
        "PIM MDT CACHE LEAF AD LEGS";
      leaf lead-ad-originator {
        type inet:ipv4-address;
        description "Leaf AD Originator";
      }
    }  // grouping PIM-MDT-CACHE-LEAF-AD-BAG

    grouping PIM-GRE-CORE {
      description "PIM - GRE core";
      leaf bgp-auto-discovery-remote-tunnel-type {
        type uint32;
        description "Remote tunnel type";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 Addr";
      }
    }  // grouping PIM-GRE-CORE

    grouping PIM-DATAMDT-CORETYPE {
      description "PIM DATAMDT CORETYPE";
      container core-pim {
        when "../mdt-type = 'gre'" {
          description "../MDTType = 'GRE'";
        }
        description "PIM - GRE core";
        uses PIM-GRE-CORE;
      }  // container core-pim

      container core-mldp {
        when "../mdt-type = 'mldp'" {
          description "../MDTType = 'MLDP'";
        }
        description "PIM - MLDP core";
        uses PIM-MLDP-CORE;
      }  // container core-mldp

      container core-identifier-p2mp {
        when "../mdt-type = 'p2mp'" {
          description "../MDTType = 'P2MP'";
        }
        description
          "Core Identifier for RSVPTE MDT";
        uses PIM-RSVPTE-CORE;
      }  // container core-identifier-p2mp

      container core-identifier-ir {
        when "../mdt-type = 'ir'" {
          description "../MDTType = 'IR'";
        }
        description
          "Core Identifier for IR MDT";
        uses PIM-IR-CORE;
      }  // container core-identifier-ir

      container core-identifier-tree-sid {
        when "../mdt-type = 'tree-sid'" {
          description
            "../MDTType = 'TreeSID'";
        }
        description
          "Core Identifier for Tree-SID MDT";
        uses PIM-TREESID-CORE;
      }  // container core-identifier-tree-sid

      leaf mdt-type {
        type Pim-bag-mdt;
        description "MDTType";
      }

      leaf core-identifier-inband {
        when "../mdt-type = 'in-band'" {
          description
            "../MDTType = 'InBand'";
        }
        type uint32;
        description
          "Core Identifier for Inband MDT";
      }
    }  // grouping PIM-DATAMDT-CORETYPE

    grouping PIM-MDT-CACHE-BAG {
      description "PIM Data MDT cache";
      container core-context {
        description "Core Context";
        uses PIM-DATAMDT-CORETYPE;
      }  // container core-context

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

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

      leaf core-source-address-xr {
        type inet:ipv4-address;
        description "Core Source Address";
      }

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

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

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

      leaf send-count {
        type uint32;
        description
          "Data MDT Join send count";
      }

      leaf receive-count {
        type uint32;
        description
          "Data MDT Join receive count";
      }

      leaf src-vrf-name {
        type string {
          length "0..33";
        }
        description "Source VRF NAme";
      }

      leaf chkpt-object-identifier {
        type uint32;
        description "Checkpoint Object ID";
      }

      list receiver-pe {
        description "Receiver PE list";
        uses PIM-MDT-CACHE-LEAF-AD-BAG;
      }  // list receiver-pe
    }  // grouping PIM-MDT-CACHE-BAG

    grouping PIM-IR-CORE {
      description "PIM - IR core";
      leaf tunnel-type {
        type uint32;
        description "Tunnel Type";
      }

      leaf label {
        type uint32;
        description "MPLS Label";
      }

      leaf lsmid {
        type uint32;
        description "LSM ID";
      }
    }  // grouping PIM-IR-CORE

    grouping PIM-MDT-TUNNEL-DB-BAG {
      description "PIM MDT TUNNEL DB bag";
      container mdt-default-ir-core {
        description "Default MDT IR core";
        uses PIM-IR-CORE;
      }  // container mdt-default-ir-core

      container default-mdt-source {
        description "Default MDT Source";
        uses PIM-ADDRTYPE;
      }  // container default-mdt-source

      container mdt-partition-ir-core {
        description
          "Partitioned MDT IR core";
        uses PIM-IR-CORE;
      }  // container mdt-partition-ir-core

      container part-mdt-source {
        description "Partitioned MDT Source";
        uses PIM-ADDRTYPE;
      }  // container part-mdt-source

      container mdt-control-ir-core {
        description "Cntrl IR core";
        uses PIM-IR-CORE;
      }  // container mdt-control-ir-core

      leaf ctrl-tree-type {
        type uint32;
        description "Ctrl Tree Type";
      }

      leaf mdt-type {
        type uint32;
        description "MDT Type";
      }

      list def-pe {
        description "Default MDT PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list def-pe

      list part-pe {
        description
          "Partitioned MDT PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list part-pe

      list ctrl-pe {
        description "Ctrl PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list ctrl-pe
    }  // grouping PIM-MDT-TUNNEL-DB-BAG

    grouping PIM-MDT-CACHE-SUMM-BAG {
      description
        "PIM Data MDT Cache Summary Bag";
      leaf cache-count {
        type uint32;
        description "Data MDT Cache count";
      }
    }  // grouping PIM-MDT-CACHE-SUMM-BAG

    grouping PIM-MDT-DATA-LEG-BAG {
      description "PIM MDT DATA LEGS";
      leaf leg-addr {
        type inet:ipv4-address;
        description "NH Leg Address";
      }

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

      leaf mvpn-label {
        type uint32;
        description "MVPN label";
      }
    }  // grouping PIM-MDT-DATA-LEG-BAG

    grouping PIM-RSVPTE-CORE {
      description "PIM - RSVPTE core";
      leaf p2mp-identifier {
        type uint32;
        description "P2MP ID";
      }

      leaf tunnel-id {
        type uint32;
        description "Tunnel Identifier";
      }

      leaf extended-tunnel-id {
        type inet:ipv4-address;
        description "Extended Tunnel ID";
      }

      leaf core-id {
        type uint32;
        description "Core ID";
      }
    }  // grouping PIM-RSVPTE-CORE

    grouping PIM-MDT-DATA-RSVPTE-BAG {
      description "PIM RSVP TE bag";
      container mdt-data-core-rsvpte {
        description "Data MDT RSVPTE core";
        uses PIM-RSVPTE-CORE;
      }  // container mdt-data-core-rsvpte

      container mdt-data-source {
        description "Data MDT Source";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-source

      leaf is-mdt-delete-in-progress {
        type boolean;
        description
          "Is the entry being deleted ?";
      }

      leaf is-mdt-local {
        type boolean;
        description
          "Is the entry locally assigned ?";
      }

      leaf mdt-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix";
      }

      leaf mdt-decapsulation-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix on Decap
         PE";
      }

      list receiver-pe {
        description "Receiver PE list";
        uses PIM-MDT-DATA-LEG-BAG;
      }  // list receiver-pe
    }  // grouping PIM-MDT-DATA-RSVPTE-BAG

    grouping PIM-P2MPTE-MDT-DATA-LEG-BAG {
      description
        "PIM P2MPTE/Tree-SID MDT LEGS";
      leaf originator-addr {
        type inet:ipv4-address;
        description "Originator Leg Address";
      }
    }  // grouping PIM-P2MPTE-MDT-DATA-LEG-BAG

    grouping PIM-TREESID-CORE {
      description "PIM - Tree-SID core";
      leaf tree-identifier {
        type uint32;
        description "Tree ID";
      }
    }  // grouping PIM-TREESID-CORE

    grouping PIM-TREESID-MDT-TUNNEL-DB-BAG {
      description
        "PIM Tree-SID MDT TUNNEL DB bag";
      container mdt-default-tree-sid-core {
        description "Default MDT Tree-SID";
        uses PIM-TREESID-CORE;
      }  // container mdt-default-tree-sid-core

      container default-mdt-source {
        description "Default MDT Source";
        uses PIM-ADDRTYPE;
      }  // container default-mdt-source

      container mdt-partition-tree-sid-core {
        description
          "Partitioned MDT Tree-SID core";
        uses PIM-TREESID-CORE;
      }  // container mdt-partition-tree-sid-core

      container part-mdt-source {
        description "Partitioned MDT Source";
        uses PIM-ADDRTYPE;
      }  // container part-mdt-source

      container mdt-control-tree-sid-core {
        description "Cntrl Tree-SID core";
        uses PIM-TREESID-CORE;
      }  // container mdt-control-tree-sid-core

      leaf mdt-type {
        type uint32;
        description "MDT Type";
      }

      leaf tree-sid-color {
        type uint32;
        description
          "On-Demand Color for Tree-SID";
      }

      leaf lfa-protected {
        type boolean;
        description "LFA Protected Tree-SID";
      }

      list def-pe {
        description "Default MDT PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list def-pe

      list part-pe {
        description
          "Partitioned MDT PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list part-pe

      list ctrl-pe {
        description "Ctrl PE list";
        uses PIM-P2MPTE-MDT-DATA-LEG-BAG;
      }  // list ctrl-pe
    }  // grouping PIM-TREESID-MDT-TUNNEL-DB-BAG

    grouping PIM-MLDP-CORE {
      description "PIM - MLDP core";
      leaf tree-type {
        type Pim-bag-mldp-tree;
        description "MLDP Tree Type";
      }

      leaf opaque-type {
        type Pim-bag-mldp-opaque;
        description "MLDP Opaque Type";
      }

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

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

      leaf core-identifier-mldp {
        type uint32;
        description
          "Core Identifier for MLDP MDT";
      }

      leaf ingress-lsm-id {
        type uint32;
        description
          "Ingress LSM Identifier for CSC MLDP MDT";
      }

      leaf egress-lsm-id {
        type uint32;
        description
          "Egress LSM Identifier for CSC MLDP MDT";
      }
    }  // grouping PIM-MLDP-CORE

    grouping PIM-MDT-DATA-MLDP-BAG {
      description "PIM Data MDT MLDP bag";
      container mdt-data-core-mldp {
        description "Data MDT MLDP core";
        uses PIM-MLDP-CORE;
      }  // container mdt-data-core-mldp

      container mdt-data-source {
        description "Data MDT Source";
        uses PIM-ADDRTYPE;
      }  // container mdt-data-source

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

      leaf is-mdt-delete-in-progress {
        type boolean;
        description
          "Is the entry being deleted ?";
      }

      leaf is-mdt-local {
        type boolean;
        description
          "Is the entry locally assigned ?";
      }

      leaf mdt-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix";
      }

      leaf mdt-decapsulation-refcount {
        type uint32;
        description
          "No of cust routes using this MDT prefix on Decap
         PE";
      }

      leaf mldp-identifier {
        type uint32;
        description "MLDP LSM-ID";
      }
    }  // grouping PIM-MDT-DATA-MLDP-BAG

    grouping PIM-SRP2MP-CONFIG-BAG {
      description "PIM SRP2MP CONFIG bag";
      container group {
        description "Group";
        uses PIM-ADDRTYPE;
      }  // container group

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

      container group-mask {
        description "Group Mask";
        uses PIM-ADDRTYPE;
      }  // container group-mask

      container source-mask {
        description "Source Mask";
        uses PIM-ADDRTYPE;
      }  // container source-mask

      leaf group-count {
        type uint32;
        description "Group Count";
      }

      leaf source-count {
        type uint32;
        description "Source Count";
      }
    }  // grouping PIM-SRP2MP-CONFIG-BAG

    grouping PIM-ADDRTYPE {
      description "PIM ADDRTYPE";
      leaf af-name {
        type Pim-afi;
        description "AFName";
      }

      leaf ipv4-address {
        when "../af-name = 'ipv4-unicast'" {
          description
            "../AFName = 'IPv4Unicast'";
        }
        type inet:ipv4-address;
        description "IPv4 Addr";
      }

      leaf ipv6-address {
        when "../af-name = 'ipv6-unicast'" {
          description
            "../AFName = 'IPv6Unicast'";
        }
        type Ipv6-address;
        description "IPV6 Addr";
      }
    }  // grouping PIM-ADDRTYPE

    grouping PIM-SRP2MP-MDT-TUNNEL-DB-BAG {
      description
        "PIM SRP2MP MDT TUNNEL DB bag";
      container ingress-node-address {
        description "Ingress Node address";
        uses PIM-ADDRTYPE;
      }  // container ingress-node-address

      leaf policy-name-xr {
        type string {
          length "0..256";
        }
        description "Policy Name";
      }

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

      leaf lsm-id {
        type uint32;
        description "LSM id";
      }

      leaf role {
        type uint32;
        description "Role";
      }

      leaf policy-stale {
        type boolean;
        description "Policy Stale";
      }

      leaf xtc-update {
        type boolean;
        description "XTC Update";
      }

      leaf config {
        type boolean;
        description "Config";
      }

      list static-config {
        description "Static Config List";
        uses PIM-SRP2MP-CONFIG-BAG;
      }  // list static-config
    }  // grouping PIM-SRP2MP-MDT-TUNNEL-DB-BAG

    grouping PIM-MDT-INTERFACE-BAG {
      description "PIM MDT interface";
      leaf mdt-group-address {
        type inet:ipv4-address;
        description "MDT Group Address";
      }

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

      leaf source-name {
        type string;
        description "Source Name";
      }

      leaf vrf-table-name {
        type string {
          length "0..33";
        }
        description "Vrf Name";
      }
    }  // grouping PIM-MDT-INTERFACE-BAG
  }  // submodule Cisco-IOS-XR-mvpn-oper-sub1