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

    yang-version 1;

    belongs-to Cisco-IOS-XR-mrib-oper {
        prefix Cisco-IOS-XR-mrib-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 mrib package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-29" {
      description
        "Adding RPFID for PIM-SM design
       2020-10-11
         Backward compatible addition in leaf table-mdt-name-tree-sid,table-tree-sid-turnaround and reference-count.";
    }

    revision "2020-02-13" {
      description "Fixing CSCvr71562.";
    }

    revision "2019-08-27" {
      description
        "Providing MRIB 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 Mrib-frr-state {
      type enumeration {
        enum "ready" {
          value 0;
          description "FRR State Ready";
        }
        enum "active" {
          value 1;
          description "FRR State Active";
        }
      }
      description " FRR State";
    }

    typedef Mrib-frr-role {
      type enumeration {
        enum "head" {
          value 1;
          description "FRR Role Head";
        }
        enum "mid" {
          value 2;
          description "FRR Role Mid";
        }
      }
      description " FRR Role";
    }

    typedef Fapid {
      type uint32;
      description "Fapid";
    }

    typedef Mrib-ccb-io {
      type enumeration {
        enum "no-data" {
          value 0;
          description "No Data";
        }
        enum "io-notify" {
          value 1;
          description "I/O Notify";
        }
        enum "data-available" {
          value 2;
          description "Data Available";
        }
        enum "invalid" {
          value 3;
          description "Invalid";
        }
      }
      description "Mrib ccb io";
    }

    typedef Mrib-evpn-bucket-state {
      type enumeration {
        enum "unknown" {
          value -1;
          description "NO State";
        }
        enum "non-forward" {
          value 0;
          description "Non Forward";
        }
        enum "forward" {
          value 1;
          description "Forward";
        }
      }
      description "Bucket State";
    }

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

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

    typedef Rsi-tbl-id {
      type uint32;
      description "Rsi tbl id";
    }

    typedef Mrib-clt {
      type enumeration {
        enum "bcdl" {
          value 0;
          description "BCDL";
        }
        enum "routing" {
          value 1;
          description "Routing";
        }
        enum "membership" {
          value 2;
          description "Membership";
        }
        enum "anonymous" {
          value 3;
          description "Anonymous";
        }
        enum "generic" {
          value 4;
          description "Generic";
        }
        enum "mrib" {
          value 5;
          description "MRIB";
        }
        enum "rsvp-te" {
          value 6;
          description "RSVP TE";
        }
        enum "ldp" {
          value 7;
          description "LDP";
        }
        enum "pim-label" {
          value 8;
          description "PIM Label";
        }
        enum "pim6-label" {
          value 9;
          description "PIM6 Label";
        }
        enum "lmrib-bcdl" {
          value 10;
          description "LMRIB BCDL";
        }
        enum "xtc" {
          value 11;
          description "XTC Agent";
        }
        enum "maximum" {
          value 12;
          description "Maximum";
        }
      }
      description "Mrib clt";
    }

    typedef Mrib-show-ctid {
      type enumeration {
        enum "any" {
          value 0;
          description "Any";
        }
        enum "spe-ipv4" {
          value 1;
          description "IPv4 LSM Source PE";
        }
        enum "ifh-ipv4" {
          value 2;
          description
            "IPv4 LSM Interface Handle";
        }
        enum "spe-ipv6" {
          value 3;
          description "IPv6 LSM Source PE";
        }
        enum "ifh-ipv6" {
          value 4;
          description
            "IPv6 LSM Interface Handle";
        }
        enum "lsm-id" {
          value 5;
          description "LSM ID";
        }
        enum "ipv4" {
          value 6;
          description "IPv4";
        }
        enum "ipv6" {
          value 7;
          description "IPv6";
        }
        enum "mldp-ifh-ipv4" {
          value 8;
          description
            "IPv4 MLDP Interface Handle";
        }
        enum "mldp-ifh-ipv6" {
          value 9;
          description
            "IPv6 MLDP Interface Handle";
        }
        enum "none" {
          value 10;
          description "None";
        }
      }
      description "Mrib show ctid";
    }

    grouping MRIB-AMT-INTRF-BAG {
      description "MRIB route AMT interface";
      container interface-attributes {
        description "Interface attributes";
        uses MRIB-ATTRIB-INTRF-BAG;
      }  // container interface-attributes

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

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

      leaf underlying-interface-node {
        type xr:Node-id;
        description
          "Node on which underlying interface is homed";
      }

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }

      leaf expiry {
        type uint64;
        description
          "Time the interface expires";
      }

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

      leaf amt-port {
        type uint32;
        description "AMT Port";
      }

      leaf amt-nexthop {
        type inet:ipv4-address;
        description "AMT Nexthop";
      }

      leaf amt-mtu {
        type uint16;
        description "AMT MTU";
      }

      leaf amt-tos {
        type uint8;
        description "AMT TOS";
      }

      leaf amt-ttl {
        type uint8;
        description "AMT TTL";
      }

      leaf amt-gateway {
        type inet:ipv4-address;
        description "AMT Gateway";
      }

      leaf amt-source {
        type inet:ipv4-address;
        description "AMT Source";
      }

      leaf amt-id {
        type uint32;
        description "AMT Identifier";
      }

      leaf out-pkts {
        type uint64;
        description "Total pkts out";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description "Total bytes out";
      }
    }  // grouping MRIB-AMT-INTRF-BAG

    grouping MRIB-AMT-ROUTE-BAG {
      description
        "MRIB multicast-routing entry";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range

      leaf amtif-count {
        type uint32;
        description "AMT Count";
      }

      list amt-interface {
        description "AMT Interfaces";
        uses MRIB-AMT-INTRF-BAG;
      }  // list amt-interface
    }  // grouping MRIB-AMT-ROUTE-BAG

    grouping MRIB-DB-SUMM-BAG {
      description "MRIB DB summary";
      leaf group-ranges {
        type uint32;
        description "No. of group ranges";
      }

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

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

      leaf forwarding-interface-count {
        type uint32;
        description "No. of RxI";
      }

      leaf route-interface-count {
        type uint32;
        description
          "Total interfaces in routes";
      }
    }  // grouping MRIB-DB-SUMM-BAG

    grouping MRIB-ATTR-STAT-BAG {
      description "MRIB attr stats";
      leaf add-rcvd-count {
        type uint32;
        description "Add received count";
      }

      leaf del-rcvd-count {
        type uint32;
        description "Del received count";
      }

      leaf add-redist-count {
        type uint32;
        description "Add redist count";
      }

      leaf del-redist-count {
        type uint32;
        description "Del redist count";
      }
    }  // grouping MRIB-ATTR-STAT-BAG

    grouping MRIB-TABLE-INFO-BAG {
      description "MRIB table info";
      container table-mdt-address {
        description "Table MDT group addr";
        uses MRIB-CTID-BAG;
      }  // container table-mdt-address

      container mdt-source {
        description "MDT Source address";
        uses MRIB-ADDRTYPE;
      }  // container mdt-source

      container mt-stat {
        description "MT stats";
        uses MRIB-ATTR-STAT-BAG;
      }  // container mt-stat

      container ma-stat {
        description "MA stats";
        uses MRIB-ATTR-STAT-BAG;
      }  // container ma-stat

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

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

      leaf registered-client {
        type string;
        description "Registered client";
      }

      leaf table-mdt-name-gre {
        type xr:Interface-name;
        description "Table GRE MDT handle";
      }

      leaf table-gre-turnaround {
        type boolean;
        description "Table GRE turnaround";
      }

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

      leaf table-mldp-turnaround {
        type boolean;
        description "Table MLDP turnaround";
      }

      leaf table-mdt-name-p2mpte {
        type xr:Interface-name;
        description
          "Table P2MPTE MDT handle";
      }

      leaf table-p2mpte-turnaround {
        type boolean;
        description
          "Table P2MPTE turnaround";
      }

      leaf table-mdt-name-ir {
        type xr:Interface-name;
        description "Table IR MDT handle";
      }

      leaf table-ir-turnaround {
        type boolean;
        description "Table IR turnaround";
      }

      leaf table-mdt-name-tree-sid {
        type xr:Interface-name;
        description
          "Table TreeSID MDT handle";
      }

      leaf table-tree-sid-turnaround {
        type boolean;
        description
          "Table TreeSID turnaround";
      }
    }  // grouping MRIB-TABLE-INFO-BAG

    grouping MRIB-AMT-GW-ID-EX-BAG {
      description
        "MRIB route AMT expired route interface";
      leaf amt-id {
        type uint32;
        description "AMT Identifier";
      }

      leaf join-time {
        type uint64;
        description
          "Time at which interface joined the active route";
      }

      leaf expire-time {
        type uint64;
        description
          "Time at which interface deleted from active and
         added to stale route";
      }

      leaf out-pkts {
        type uint64;
        description "Total pkts out";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description "Total bytes out";
      }
    }  // grouping MRIB-AMT-GW-ID-EX-BAG

    grouping MRIB-AMT-ROUTE-EX-BAG {
      description
        "MRIB AMT expired route entry";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group {
        description "Group range";
        uses MRIB-ADDRTYPE;
      }  // container group

      leaf gw-address-xr {
        type inet:ipv4-address;
        description "GW address";
      }

      leaf gw-port {
        type uint32;
        description "GW port";
      }

      leaf gwid-count {
        type uint32;
        description "AMT Count";
      }

      list gw-id {
        description "AMT GW Interfaces";
        uses MRIB-AMT-GW-ID-EX-BAG;
      }  // list gw-id
    }  // grouping MRIB-AMT-ROUTE-EX-BAG

    grouping MRIB-MPLS-DB-BAG {
      description "MRIB mpls db";
      leaf ctid-type {
        type uint32;
        description "CTID Type";
      }

      leaf source-pe-address {
        type uint32;
        description "Source PE Address";
      }

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

      leaf encap-count {
        type uint32;
        description "Encap Num";
      }

      leaf-list encap-identifier {
        type uint32;
        description "Encap List";
      }
    }  // grouping MRIB-MPLS-DB-BAG

    grouping MRIB-MPLS-FRR-OB-INFOS-BAG {
      description
        "MRIB mpls output with backup info";
      leaf output-interface {
        type xr:Interface-name;
        description "Output IFH";
      }

      leaf backup-tunnel {
        type uint32;
        description "Backup Tunnel";
      }

      leaf output-label {
        type uint32;
        description "OutLabel";
      }

      leaf backup-label {
        type uint32;
        description "Backup Label";
      }

      leaf backup-state {
        type Mrib-frr-state;
        description "Backup State";
      }
    }  // grouping MRIB-MPLS-FRR-OB-INFOS-BAG

    grouping MRIB-MPLS-FRR-BAG {
      description "MRIB mpls frr";
      leaf in-label {
        type uint32;
        description "InLabel";
      }

      leaf role {
        type Mrib-frr-role;
        description "Role";
      }

      leaf tunnel-identifier {
        type uint32;
        description "Tunnel ID";
      }

      leaf p2mp-identifier {
        type uint32;
        description "P2MP ID";
      }

      leaf lsp-identifier {
        type uint32;
        description "LSP ID";
      }

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

      leaf extended-tunnel-identifier {
        type uint32;
        description "Extented Tunnel ID";
      }

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

      leaf ob-info-number {
        type uint32;
        description "OB Info Num";
      }

      list output-information {
        description "Output Information";
        uses MRIB-MPLS-FRR-OB-INFOS-BAG;
      }  // list output-information
    }  // grouping MRIB-MPLS-FRR-BAG

    grouping MRIB-LABEL-TABLE-INFO-BAG {
      description "MRIB label table info";
      leaf table-id {
        type uint32;
        description "Table id";
      }

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

      leaf registered-client {
        type string;
        description "Registered client";
      }
    }  // grouping MRIB-LABEL-TABLE-INFO-BAG

    grouping MRIB-RC-EOLE-DB-BAG {
      description "MRIB RC route";
      leaf rc-encapsulation-identifier {
        type uint32;
        description "Encap ID";
      }
    }  // grouping MRIB-RC-EOLE-DB-BAG

    grouping MRIB-RC-ROUTEDB-BAG {
      description "MRIB RC route";
      container rc-source-address {
        description "Source Address";
        uses MRIB-ADDRTYPE;
      }  // container rc-source-address

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

      leaf rc-table-id {
        type uint32;
        description "Route TID";
      }

      leaf rc-group-prefix-length {
        type uint16;
        description "Group prefix length";
      }
    }  // grouping MRIB-RC-ROUTEDB-BAG

    grouping MRIB-RC-MDT-BAG {
      description "MRIB RC MDT database";
      container rc-mdt-address {
        description "MDT group addr";
        uses MRIB-CTID-BAG;
      }  // container rc-mdt-address

      leaf rc-mdt-table-id {
        type uint32;
        description "MDT table id";
      }

      leaf rc-mdt-remote-table-id {
        type uint32;
        description "MDT remote table id";
      }

      leaf rc-tlc-table-id {
        type uint32;
        description "TLC table id";
      }

      leaf rc-remote-tlc-table-id {
        type uint32;
        description "Remote TLC table id";
      }

      list customer {
        description "List of customer route";
        uses MRIB-RC-ROUTEDB-BAG;
      }  // list customer

      list encap-ole {
        description "List of encap oles";
        uses MRIB-RC-EOLE-DB-BAG;
      }  // list encap-ole

      list core {
        description "List of core route";
        uses MRIB-RC-ROUTEDB-BAG;
      }  // list core

      list core-egress {
        description
          "List of core egress node";
        uses MRIB-MDT-NODE-BAG;
      }  // list core-egress
    }  // grouping MRIB-RC-MDT-BAG

    grouping MRIB-AMT-ROUTE-SUMMARY-BAG {
      description "MRIB amt routing summary";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range

      leaf amt-gateway-count {
        type uint32;
        description
          "Number of AMT Gateways in this route";
      }

      leaf active-packets-sent {
        type uint64;
        description
          "Packets sent for active route";
      }

      leaf active-bytes-sent {
        type uint64;
        units "byte";
        description
          "Bytes sent for active route";
      }

      leaf ex-packets-sent {
        type uint64;
        description
          "Packets sent for expired route";
      }

      leaf ex-bytes-sent {
        type uint64;
        units "byte";
        description
          "Bytes sent for expired route";
      }
    }  // grouping MRIB-AMT-ROUTE-SUMMARY-BAG

    grouping MRIB-AMT-GW-EX-ROUTE-BAG {
      description
        "MRIB amt gw expired route";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group {
        description "Group range";
        uses MRIB-ADDRTYPE;
      }  // container group

      leaf amt-id {
        type uint32;
        description "AMT Identifier";
      }

      leaf join-time {
        type uint64;
        description
          "Time at which interface joined the active route";
      }

      leaf expire-time {
        type uint64;
        description
          "Time at which interface left active route";
      }

      leaf out-pkts {
        type uint64;
        description "Total pkts out";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description "Total bytes out";
      }
    }  // grouping MRIB-AMT-GW-EX-ROUTE-BAG

    grouping MRIB-AMT-GW-EX-BAG {
      description
        "MRIB AMT gw expired database";
      leaf gw-addr {
        type inet:ipv4-address;
        description "GW address";
      }

      leaf gw-port {
        type uint32;
        description "PORT";
      }

      list expired-route {
        description "AMT Interfaces";
        uses MRIB-AMT-GW-EX-ROUTE-BAG;
      }  // list expired-route
    }  // grouping MRIB-AMT-GW-EX-BAG

    grouping MRIB-ROUTE-OLE-BAG {
      description
        "MRIB route OLE informaton";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range

      container entry-attributes {
        description
          "Routing entry attributes";
        uses MRIB-ATTRIB-ENTRY-BAG;
      }  // container entry-attributes

      leaf uptime {
        type uint64;
        units "second";
        description
          "Time (in seconds) route has been active";
      }

      leaf ole-count {
        type uint32;
        description
          "Outgoing interface count of the route";
      }
    }  // grouping MRIB-ROUTE-OLE-BAG

    grouping MRIB-AMT-GW-ACTIVE-ROUTE-BAG {
      description "MRIB AMT gw active route";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group {
        description "Group range";
        uses MRIB-ADDRTYPE;
      }  // container group

      leaf amt-id {
        type uint32;
        description "AMT Identifier";
      }

      leaf join-time {
        type uint64;
        description
          "Time at which interface joined the active route";
      }

      leaf out-pkts {
        type uint64;
        description "Total pkts out";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description "Total bytes out";
      }
    }  // grouping MRIB-AMT-GW-ACTIVE-ROUTE-BAG

    grouping MRIB-AMT-GW-BAG {
      description "MRIB AMT gw entry";
      leaf gw-addr {
        type inet:ipv4-address;
        description "GW address";
      }

      leaf gw-port {
        type uint32;
        description "GW port";
      }

      list active-route {
        description "AMT Interfaces";
        uses MRIB-AMT-GW-ACTIVE-ROUTE-BAG;
      }  // list active-route
    }  // grouping MRIB-AMT-GW-BAG

    grouping MRIB-IIR-SUB-NODE-BAG {
      description "MRIB IIR sub node";
      leaf sub-interface {
        type xr:Interface-name;
        description "IIR sub node interface";
      }

      leaf sub-interface-name {
        type string {
          length "0..65";
        }
        description
          "IIR sub node interface name";
      }

      leaf reference-count {
        type uint32;
        description
          "Reference count of Child";
      }
    }  // grouping MRIB-IIR-SUB-NODE-BAG

    grouping MRIB-IIR-ROUTE-BAG {
      description "MRIB IIR route";
      container iir-source-address {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container iir-source-address

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

      leaf iir-route-table-id {
        type uint32;
        description "IIR route table id";
      }

      leaf iir-group-prefix-length {
        type uint16;
        description "Group prefix length";
      }

      leaf virtual-interface-count {
        type uint32;
        description
          "Virtual Interface count";
      }

      leaf-list virtual-interface {
        type xr:Interface-name;
        description "Virtual interface list";
      }
    }  // grouping MRIB-IIR-ROUTE-BAG

    grouping MRIB-IIR-INTF-BAG {
      description "MRIB IIR interface";
      leaf iir-interface {
        type xr:Interface-name;
        description "IIR interface";
      }

      leaf iir-interface-name {
        type string {
          length "0..65";
        }
        description "IIR interface name";
      }

      leaf is-virtual-interface {
        type boolean;
        description
          "Is virtual interface entry";
      }

      leaf is-iir-notified-interface {
        type boolean;
        description
          "Is IIR recognized interface";
      }

      leaf is-delete-in-progress {
        type boolean;
        description
          "Is interface marked delete in progress";
      }

      leaf child-count {
        type uint32;
        description "Child count";
      }

      leaf interface-character {
        type uint32;
        description
          "Value of if_char from pfi";
      }

      leaf interface-type {
        type uint32;
        description "Interface type";
      }

      leaf if-name {
        type string {
          length "0..65";
        }
        description "Interface name";
      }

      leaf interface-ul-index {
        type uint32;
        description "Interface UL index";
      }

      list route {
        description
          "List of route associated with this entry";
        uses MRIB-IIR-ROUTE-BAG;
      }  // list route

      list parent {
        description
          "List of parent sub node";
        uses MRIB-IIR-SUB-NODE-BAG;
      }  // list parent

      list child {
        description "List of child sub node";
        uses MRIB-IIR-SUB-NODE-BAG;
      }  // list child
    }  // grouping MRIB-IIR-INTF-BAG

    grouping MRIB-MPLS-FRR-SUMMARY-BAG {
      description
        " MRIB mpls frr summary bag ";
      leaf frr-active-count {
        type uint32;
        description "Num of Active FRR";
      }

      leaf frr-ready-count {
        type uint32;
        description "Num of Ready FRR";
      }
    }  // grouping MRIB-MPLS-FRR-SUMMARY-BAG

    grouping MRIB-TLC-MDT-BAG {
      description "MRIB MDT group";
      container mdt-core-tree-identifier {
        description
          "MDT Core Tree Identifier";
        uses MRIB-CTID-BAG;
      }  // container mdt-core-tree-identifier

      leaf mdt-table-id {
        type uint32;
        description "MDT table id";
      }

      leaf mdt-remote-table-id {
        type uint32;
        description "MDT remote table id";
      }

      leaf remote-lc-table-id {
        type uint32;
        description
          "MDT Remote TLC Table id";
      }

      leaf remote-master-lc-fapid {
        type uint32;
        description
          "MDT Remote Master LC Fapid";
      }

      list remote-lc-node {
        description
          "MDT Remote TLC list of forwarding node";
        uses MRIB-MDT-NODE-BAG;
      }  // list remote-lc-node
    }  // grouping MRIB-TLC-MDT-BAG

    grouping MRIB-MDT-NODE-BAG {
      description "MRIB MDT node";
      leaf fapid {
        type uint32;
        description "Fapid";
      }

      leaf reference-count1 {
        type uint32;
        description "Ref count 1";
      }

      leaf reference-count2 {
        type uint32;
        description "Ref count 2";
      }

      leaf reference-count3 {
        type uint32;
        description "Ref count 3";
      }

      leaf is-mlc-fallback {
        type boolean;
        description "MLC fallback";
      }

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

      leaf is-nsf-remote {
        type boolean;
        description "NSF Remote interest";
      }

      leaf is-remote-encap {
        type boolean;
        description "Remote Encap interest";
      }
    }  // grouping MRIB-MDT-NODE-BAG

    grouping MRIB-TLC-BAG {
      description "MRIB TLC database";
      leaf tlc-table-id {
        type uint32;
        description "Table id";
      }

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

      leaf mlc-fapid {
        type uint32;
        description "Master LC fapid";
      }

      leaf vfallback-master-lc-interface-handle {
        type uint32;
        description
          "Virtual fallback master linecard interface
         handle. A non-zero value indicates that there
         exists a virtual master line card interface.
         Exact value for internal diagnostic";
      }

      list node {
        description
          "List of forwarding node";
        uses MRIB-MDT-NODE-BAG;
      }  // list node

      list mdt {
        description
          "List of associated MDT route";
        uses MRIB-TLC-MDT-BAG;
      }  // list mdt
    }  // grouping MRIB-TLC-BAG

    grouping MRIB-INTRF-BAG {
      description
        "MRIB multicast-routing entry-interface";
      container interface-attributes {
        description "Interface attributes";
        uses MRIB-ATTRIB-INTRF-BAG;
      }  // container interface-attributes

      container if-mdf-attr {
        description
          "Interface modified attributes";
        uses MRIB-ATTRIB-INTRF-BAG;
      }  // container if-mdf-attr

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

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

      leaf underlying-interface-node {
        type Fapid;
        description
          "Fapid on which underlying interface is homed";
      }

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }

      leaf expiry {
        type uint64;
        description
          "Time the interface expires";
      }

      leaf li-add-redist-count {
        type uint8;
        description "LI add redist count";
      }

      leaf li-del-redist-count {
        type uint8;
        description "LI del redist count";
      }

      leaf backup-fgid-added {
        type boolean;
        description
          "Interfaec added to backup fgid or not";
      }

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

      leaf gre-encapsulation-source-address {
        type inet:ipv4-address;
        description
          "MDT GRE Encapsulation Source Address";
      }

      leaf gre-encapsulation-group-address {
        type inet:ipv4-address;
        description
          "MDT GRE Encapsulation Group Address";
      }

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

      leaf amt-port {
        type uint32;
        description "AMT Port";
      }

      leaf amt-nexthop {
        type inet:ipv4-address;
        description "AMT Nexthop";
      }

      leaf amt-mtu {
        type uint16;
        description "AMT MTU";
      }

      leaf amt-tos {
        type uint8;
        description "AMT TOS";
      }

      leaf amt-ttl {
        type uint8;
        description "AMT TTL";
      }

      leaf amt-gateway {
        type inet:ipv4-address;
        description "AMT Gateway";
      }

      leaf amt-source {
        type inet:ipv4-address;
        description "AMT Source";
      }

      leaf amt-id {
        type uint32;
        description "AMT Identifier";
      }
    }  // grouping MRIB-INTRF-BAG

    grouping MRIB-ROUTE-BAG {
      description
        "MRIB multicast-routing entry";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range

      container orig-source {
        description "Orig Source address";
        uses MRIB-ADDRTYPE;
      }  // container orig-source

      container parent-range {
        description
          "Parent if entry is Bidir";
        uses MRIB-GROUP-RNG-BAG;
      }  // container parent-range

      container rpf-neighbor {
        description "RPFneighbour address";
        uses MRIB-ADDRTYPE;
      }  // container rpf-neighbor

      container mdt-core-tree-identifier {
        description
          "MDT CTID - address for v4 and v6 MVPN";
        uses MRIB-CTID-BAG;
      }  // container mdt-core-tree-identifier

      container entry-attributes {
        description
          "Routing entry attributes";
        uses MRIB-ATTRIB-ENTRY-BAG;
      }  // container entry-attributes

      container rc-mdt-ctid {
        description
          "Route-collapse MDT CTID in use";
        uses MRIB-CTID-BAG;
      }  // container rc-mdt-ctid

      container entry-attr-mdf {
        description
          "Routing entry attributes mdf";
        uses MRIB-ATTRIB-ENTRY-BAG;
      }  // container entry-attr-mdf

      leaf route-version {
        type uint16;
        description "Route Version";
      }

      leaf is-customer-encapsulation-route {
        type boolean;
        description "Cust Encap route";
      }

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

      leaf customer-table-id {
        type uint32;
        description "Customer table id";
      }

      leaf remote-customer-table-id {
        type uint32;
        description
          "Remote Customer table id";
      }

      leaf mdt-interface-handle-xr {
        type uint32;
        description "MDT interface handle";
      }

      leaf mdt-turnaround-enabled {
        type boolean;
        description "MDT Turnaround ?";
      }

      leaf mdt-bgp-interface-handle {
        type uint32;
        description
          "MDT BGP interface handle";
      }

      leaf payload {
        type uint32;
        description
          "The type of the encapsulated payload";
      }

      leaf master-lc-fapid {
        type uint32;
        description "Master LC Fapid";
      }

      leaf master-lc-fallback-fapid {
        type uint32;
        description
          "Master LC Fallback Fapid";
      }

      leaf mt-lc-fapid {
        type uint32;
        description "MT flag LC Fapid";
      }

      leaf annotation {
        type string;
        description "Platform annotation";
      }

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }

      leaf mdt-interface-handle {
        type uint32;
        description "Special MDT handle";
      }

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

      leaf mo-frr-active {
        type uint32;
        description "MOFRR Active Bit";
      }

      leaf mo-frr-seq-no {
        type uint32;
        description "MoFRR Seq Number";
      }

      leaf encapsulation-identifier {
        type uint32;
        description "Encap-ID value";
      }

      leaf in-expired-db {
        type boolean;
        description
          "Is route present in expired databse";
      }

      list interface {
        description "Interfaces";
        uses MRIB-INTRF-BAG;
      }  // list interface
    }  // grouping MRIB-ROUTE-BAG

    grouping MRIB-MPLS-BKUP-TUN-BAG {
      description "MRIB mpls bkup tun";
      leaf protected-interface {
        type xr:Interface-name;
        description "Protected Intf IFH";
      }

      leaf backup-tunnel {
        type uint32;
        description "Backup Tunnel";
      }

      leaf backup-out-intf {
        type uint32;
        description "Backup Out Interface";
      }

      leaf backup-label {
        type uint32;
        description "Backup Label";
      }

      leaf backup-active {
        type boolean;
        description "Backup Active";
      }

      leaf-list in-label {
        type uint32;
        description
          "Label Entries using this bkup";
      }
    }  // grouping MRIB-MPLS-BKUP-TUN-BAG

    grouping MRIB-MPLS-BKUP-BAG {
      description "MRIB mpls bkup";
      leaf te-client {
        type boolean;
        description "TE Client populated";
      }

      leaf lmrib-entry {
        type boolean;
        description "LMRIB Entry populated";
      }

      leaf prot-if-name {
        type string;
        description "Protected Intf Name";
      }

      list backup-tunnel {
        description "Backup Tunnels";
        uses MRIB-MPLS-BKUP-TUN-BAG;
      }  // list backup-tunnel
    }  // grouping MRIB-MPLS-BKUP-BAG

    grouping MRIB-AMT-GW-SUMMARY-BAG {
      description
        "MRIB AMT gw summary route";
      leaf gw-addr {
        type inet:ipv4-address;
        description "GW address";
      }

      leaf gw-port {
        type uint32;
        description "PORT";
      }

      leaf active-route-count {
        type uint32;
        description
          "Active routes for this Gateway";
      }

      leaf out-pkts {
        type uint64;
        description "Total pkts out";
      }

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

      leaf out-ex-pkts {
        type uint64;
        description
          "Total expired route pkts out";
      }

      leaf out-ex-bytes {
        type uint64;
        units "byte";
        description
          "Total expired route bytes out";
      }
    }  // grouping MRIB-AMT-GW-SUMMARY-BAG

    grouping MRIB-RC-IPC-BAG {
      description "MRIB RC IPC";
      leaf ipc-name {
        type string;
        description "IPC name";
      }

      leaf items-in-ring {
        type uint32;
        description "Items in Ring";
      }

      leaf consumer-waiting {
        type boolean;
        description "Consumer Waiting";
      }

      leaf producer-flags {
        type uint32;
        description "Producer Flags";
      }

      leaf node-updates {
        type uint32;
        description
          "Nodes Updated On Producer Channel";
      }

      leaf shared-memory-open-failures {
        type uint32;
        description
          "Consumer IPC thread shared memory open failures";
      }

      leaf shared-memory-fstat-failures {
        type uint32;
        description
          "Consumer IPC thread shared memory fstat failures";
      }

      leaf shared-memory-size-failures {
        type uint32;
        description
          "Consumer IPC thread shared memory size failures";
      }

      leaf shared-memory-map-failures {
        type uint32;
        description
          "Consumer IPC thread shared memory mmap failures";
      }

      leaf shared-memory-header-failures {
        type uint32;
        description
          "Consumer IPC thread shared memory header
         validation failures";
      }
    }  // grouping MRIB-RC-IPC-BAG

    grouping MRIB-ENCAPID-TBLID-BAG {
      description "MRIB Encap Table Entry";
      leaf etable-id {
        type uint32;
        description "Encap Table id";
      }

      leaf refcount {
        type uint32;
        description "Refcount";
      }
    }  // grouping MRIB-ENCAPID-TBLID-BAG

    grouping MRIB-ENCAPID-NODE-BAG {
      description "MRIB Encap Node Entry";
      leaf node-id {
        type xr:Node-id;
        description "NodeID";
      }

      leaf refcount {
        type uint32;
        description "Refcount";
      }
    }  // grouping MRIB-ENCAPID-NODE-BAG

    grouping MRIB-ENCAPID-OLE-BAG {
      description "MRIB Encap Ole Entry";
      leaf type {
        type Mrib-show-ctid;
        description "Type";
      }

      leaf-list ole-key {
        type uint8;
        description "Ole Key";
      }
    }  // grouping MRIB-ENCAPID-OLE-BAG

    grouping ENCAPID-REDIST-INFO {
      description "ENCAPID REDIST INFO";
      leaf redist-flags {
        type uint8;
        description "redist flags";
      }

      leaf client-id {
        type uint32;
        description "client id";
      }

      leaf client-redist-time {
        type uint64;
        description "client redist time";
      }
    }  // grouping ENCAPID-REDIST-INFO

    grouping MRIB-ENCAPID-BAG {
      description "MRIB Encap Entry";
      leaf encap-id-xr {
        type uint32;
        description "Encap ID value";
      }

      leaf expiration-time {
        type uint64;
        units "second";
        description
          "Expiration time in seconds";
      }

      leaf expirationvalid {
        type boolean;
        description
          "Expiration valid or not";
      }

      leaf vrf-lite {
        type boolean;
        description "Vrf Lite";
      }

      leaf v6-vrf-lite {
        type boolean;
        description "V6 Vrf Lite";
      }

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

      leaf ipv6-usage {
        type boolean;
        description
          "IPV6 using this encap id";
      }

      leaf route-count {
        type uint32;
        description
          "No. of routes using this Encap ID";
      }

      leaf annotation {
        type string;
        description "Platform annotation";
      }

      leaf-list encap-id-key {
        type uint8;
        description "EncapID Key";
      }

      list redist-info {
        max-elements 3;
        description "Redist Info";
        uses ENCAPID-REDIST-INFO;
      }  // list redist-info

      list encap-id-ole {
        description "EncapID ole";
        uses MRIB-ENCAPID-OLE-BAG;
      }  // list encap-id-ole

      list node-id {
        description "NodeID list";
        uses MRIB-ENCAPID-NODE-BAG;
      }  // list node-id

      list backup-node-id {
        description "Backup NodeID list";
        uses MRIB-ENCAPID-NODE-BAG;
      }  // list backup-node-id

      list encap-t-id {
        description "Encap Table Id list";
        uses MRIB-ENCAPID-TBLID-BAG;
      }  // list encap-t-id
    }  // grouping MRIB-ENCAPID-BAG

    grouping MRIB-ATTRIB-INTRF-BAG {
      description
        "MRIB Interface level flags";
      leaf is-forward {
        type boolean;
        description "Forwarding flag";
      }

      leaf is-accept {
        type boolean;
        description "Accepting flag";
      }

      leaf is-accept-backup {
        type boolean;
        description "Accepting Backup flag";
      }

      leaf is-internal-copy {
        type boolean;
        description "Internal Copy flag";
      }

      leaf is-negate-signal {
        type boolean;
        description "NegateSignal";
      }

      leaf is-dont-preserve {
        type boolean;
        description "Don't preserve flag";
      }

      leaf is-signal-present {
        type boolean;
        description "Signal Present flag";
      }

      leaf is-internal-interest {
        type boolean;
        description "Internal Interest flag";
      }

      leaf is-internal-disinterest {
        type boolean;
        description
          "Internal Disinterest flag";
      }

      leaf is-local-interest {
        type boolean;
        description "Local Interest flag";
      }

      leaf is-local-disinterest {
        type boolean;
        description "Local Disinterest flag";
      }

      leaf is-decapsulation-interface {
        type boolean;
        description "Decaps interface flag";
      }

      leaf is-underlying-physical-change {
        type boolean;
        description
          "Underlying physical change flag";
      }

      leaf is-encapsulation-interface {
        type boolean;
        description "Encaps interface flag";
      }

      leaf is-egress-interface {
        type boolean;
        description "Egress processing flag";
      }

      leaf is-extranet {
        type boolean;
        description "Extranet";
      }

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

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

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

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

      leaf is-mdt-data-triggered {
        type boolean;
        description
          "Data MDT triggered on this interface";
      }

      leaf is-p2mp-interface {
        type boolean;
        description "P2MP interface flag";
      }

      leaf is-turn-around {
        type boolean;
        description "Turnaround candidate";
      }

      leaf amt {
        type boolean;
        description "AMT";
      }

      leaf is-tr-mdt-interface {
        type boolean;
        description "TR MDT interface flag";
      }

      leaf evpn-mh-interface {
        type boolean;
        description "EVPN MH Interface flag";
      }
    }  // grouping MRIB-ATTRIB-INTRF-BAG

    grouping MRIB-ATTRIB-ENTRY-BAG {
      description "MRIB Entry level flags";
      leaf is-domain-local-source {
        type boolean;
        description
          "Domain-local source flag";
      }

      leaf is-source-external {
        type boolean;
        description
          "Source external to domain";
      }

      leaf is-signal-by-default-on {
        type boolean;
        description "Signal by default";
      }

      leaf is-directly-connected-check-set {
        type boolean;
        description
          "Directly connected check";
      }

      leaf is-inherit-accept-set {
        type boolean;
        description "Inherit Accept info";
      }

      leaf is-inherit-from-set {
        type boolean;
        description "Inherit from info";
      }

      leaf is-drop {
        type boolean;
        description "Drop flag";
      }

      leaf is-rpf-neighbor-present {
        type boolean;
        description
          "RPF neighbor present flag";
      }

      leaf is-multicast-nsf-on {
        type boolean;
        description "Multicast NSF flag";
      }

      leaf is-mdt-encapsulation-on {
        type boolean;
        description "MDT Encap flag";
      }

      leaf is-mdt-decapsulation-on {
        type boolean;
        description "MDT Decap flag";
      }

      leaf is-mdt-interface-on {
        type boolean;
        description "MDT ifh flag";
      }

      leaf is-mdt-bgp-interface-on {
        type boolean;
        description "MDT BGP ifh flag";
      }

      leaf is-master-lc-on {
        type boolean;
        description "Master LC flag";
      }

      leaf is-master-lc-fallback-on {
        type boolean;
        description "Master LC FB flag";
      }

      leaf is-mdt-address-on {
        type boolean;
        description "MDT Address flag";
      }

      leaf is-platform-modified {
        type boolean;
        description "Platform modified flag";
      }

      leaf is-threshold-crossed {
        type boolean;
        description
          "Data MDT Threshold Crossed";
      }

      leaf is-conditional-decap {
        type boolean;
        description "Conditional Decap";
      }

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

      leaf is-forward-mpls {
        type boolean;
        description "MPLS Forward";
      }

      leaf is-extranet {
        type boolean;
        description "Extranet";
      }

      leaf is-mdt-interface-special-on {
        type boolean;
        description "MDT ifh special flag";
      }

      leaf encapsulation-identifier-flag {
        type boolean;
        description "Encap-ID present";
      }

      leaf rpf-identifier-flag {
        type boolean;
        description "RPF-ID present";
      }

      leaf candidate-mofrr {
        type boolean;
        description "MoFRR candidate route";
      }

      leaf mofrr-state {
        type boolean;
        description "Is the MoFRR bit set";
      }

      leaf mofrr-primary {
        type boolean;
        description
          "Is the MoFRR primary bit set";
      }

      leaf mofrr-backup {
        type boolean;
        description
          "Is the MoFRR backup bit set";
      }

      leaf protocol {
        type boolean;
        description "Protocol value set";
      }

      leaf amt {
        type boolean;
        description "AMT flag";
      }

      leaf initial-convergence-done {
        type boolean;
        description "ICD flag";
      }

      leaf vxlan {
        type boolean;
        description "VXLAN flag";
      }
    }  // grouping MRIB-ATTRIB-ENTRY-BAG

    grouping MRIB-SIMPLE-FILTER-BAG {
      description
        "Mrib client simple-filter";
      list mrib-simple-filter-bag {
        description "Chain of diff filters";
        container entry-attributes {
          description "Per-entry attributes";
          uses MRIB-ATTRIB-ENTRY-BAG;
        }  // container entry-attributes

        container interface-attributes {
          description
            "Per-interface attributes";
          uses MRIB-ATTRIB-INTRF-BAG;
        }  // container interface-attributes

        leaf-list include-interface {
          type xr:Interface-name;
          description
            "Include-mode interfaces";
        }

        leaf-list exclude-interface {
          type xr:Interface-name;
          description
            "Exclude-mode interfaces";
        }

        list include-group {
          description "Include-mode groups";
          uses MRIB-GROUP-RNG-BAG;
        }  // list include-group

        list exclude-group {
          description "Exclude-mode groups";
          uses MRIB-GROUP-RNG-BAG;
        }  // list exclude-group
      }  // list mrib-simple-filter-bag
    }  // grouping MRIB-SIMPLE-FILTER-BAG

    grouping MRIB-FILTER-BAG {
      description "Mrib client filter";
      container filter-interest {
        description "Interest filter";
        uses MRIB-SIMPLE-FILTER-BAG;
      }  // container filter-interest

      container filter-owned {
        description "Ownership filter";
        uses MRIB-SIMPLE-FILTER-BAG;
      }  // container filter-owned

      leaf client-connection-id {
        type uint32;
        description "Client-connection id";
      }

      leaf client-name-xr {
        type string;
        description "Client name";
      }

      leaf client-instance-id {
        type string;
        description "Client instance ID";
      }
    }  // grouping MRIB-FILTER-BAG

    grouping MRIB-RPFID-SPE-INFO {
      description "MRIB RPFID SPE INFO";
      leaf addr {
        type inet:ipv4-address;
        description "addr";
      }

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

      leaf id-alloc {
        type boolean;
        description "id alloc";
      }

      leaf tbl-id {
        type Rsi-tbl-id;
        description "tbl id";
      }

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

      leaf ipv6-interest {
        type boolean;
        description "ipv6 interest";
      }

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

      leaf chkpt-obj-id {
        type uint32;
        description "chkpt obj id";
      }

      leaf dep-route-list-cnt {
        type uint32;
        description "dep route list cnt";
      }

      leaf dep-core-route-list-cnt {
        type uint32;
        description
          "dep core route list cnt";
      }

      leaf dep-label-list-cnt {
        type uint32;
        description "dep label list cnt";
      }

      leaf in-pd-retry-list {
        type boolean;
        description "in pd retry list";
      }

      leaf annotation {
        type string;
        description "Platform annotation";
      }
    }  // grouping MRIB-RPFID-SPE-INFO

    grouping MRIB-NSF-BAG {
      description "MRIB NSF state";
      leaf is-multicast-nsf {
        type boolean;
        description "Multicast NSF state";
      }

      leaf is-multicast-cofonsf {
        type boolean;
        description
          "Multicast COFO NSF state";
      }

      leaf multicast-nsf-timeout {
        type uint32;
        description "Multicast NSF timeout";
      }

      leaf multicast-nsf-time-left {
        type uint32;
        description
          "Multicast NSF time remaining";
      }

      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;
        description
          "Last NSF time ON in Sec";
      }

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

      leaf last-icd-notif-sent {
        type int64;
        description "Last ICD Notif Sent";
      }

      leaf last-icd-notif-sent-sec {
        type int32;
        description
          "Last ICD Notif Sent in Sec";
      }

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

      leaf last-remote-nsf-off {
        type int64;
        description "Last Remote NSF OFF";
      }

      leaf last-label-mldp-nsf-on {
        type int64;
        description "Last Label MLDP NSF ON";
      }

      leaf last-label-mldp-nsf-off {
        type int64;
        description
          "Last Label MLDP NSF OFF";
      }

      leaf last-label-te-nsf-on {
        type int64;
        description "Last Label TE NSF ON";
      }

      leaf last-labelte-nsf-off {
        type int64;
        description "Last Label TE NSF OFF";
      }

      leaf last-label-pim-nsf-on {
        type int64;
        description "Last Label PIM NSF ON";
      }

      leaf last-label-pim-nsf-off {
        type int64;
        description "Last Label PIM NSF OFF";
      }

      leaf last-label-pim6nsf-on {
        type int64;
        description "Last Label PIM6 NSF ON";
      }

      leaf last-label-pim6-nsf-off {
        type int64;
        description
          "Last Label PIM6 NSF OFF";
      }

      leaf last-remote-nsf-on-sec {
        type int32;
        description
          "Last Remote NSF ON in Sec";
      }

      leaf last-remote-nsf-off-sec {
        type int32;
        description
          "Last Remote NSF OFF in Sec";
      }

      leaf last-label-mldp-nsf-on-sec {
        type int32;
        description
          "Last Label MLDP NSF ON in Sec";
      }

      leaf last-label-mldp-nsf-off-sec {
        type int32;
        description
          "Last Label MLD NSF OFF in Sec";
      }

      leaf last-label-te-nsf-on-sec {
        type int32;
        description
          "Last Label TE NSF ON in Sec";
      }

      leaf last-labelte-nsf-off-sec {
        type int32;
        description
          "Last Label TE NSF OFF in Sec";
      }

      leaf last-label-pim-nsf-on-sec {
        type int32;
        description
          "Last Label PIM NSF ON in Sec";
      }

      leaf last-label-pim-nsf-off-sec {
        type int32;
        description
          "Last Label PIM NSF OFF in Sec";
      }

      leaf last-label-pim6nsf-on-sec {
        type int32;
        description
          "Last Label PIM6 NSF ON in Sec";
      }

      leaf last-label-pim6-nsf-off-sec {
        type int32;
        description
          "Last Label PIM6 NSF OFF in Sec";
      }
    }  // grouping MRIB-NSF-BAG

    grouping MRIB-MPLS-OUTINFOS-BAG {
      description "MRIB mpls output info";
      leaf output-interface {
        type xr:Interface-name;
        description "Output IFH";
      }

      leaf output-underlying-interface {
        type xr:Interface-name;
        description "Output Underlying IFH";
      }

      leaf out-nh {
        type uint32;
        description "Nexthop";
      }

      leaf out-nhid {
        type uint32;
        description "Nexthop ID";
      }

      leaf output-label {
        type uint32;
        description "OutLabel";
      }

      leaf out-fapid {
        type uint32;
        description "Output Fapid";
      }

      leaf backup {
        type uint32;
        description "Backup";
      }

      leaf backup-active {
        type uint32;
        description "Backup Active";
      }

      leaf backup-tunnel {
        type uint32;
        description "Backup Tunnel";
      }

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

      leaf backup-underlying-interface {
        type xr:Interface-name;
        description "Backup Underlying IFH";
      }

      leaf backup-label {
        type uint32;
        description "Backup Label";
      }

      leaf backup-nh {
        type uint32;
        description "Backup Nexthop";
      }

      leaf bacup-fapid {
        type uint32;
        description "Backup Fapid";
      }

      leaf s2l-role {
        type uint32;
        description "S2L Role";
      }

      leaf output-information {
        type uint32;
        description "Output Information";
      }

      leaf oiis-nh-type {
        type boolean;
        description
          "Output Information is NHType";
      }

      leaf selected-output-interface {
        type xr:Interface-name;
        description
          "Selected output innterface";
      }

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

      leaf annotation {
        type string;
        description
          "OutInfo Platform annotation";
      }
    }  // grouping MRIB-MPLS-OUTINFOS-BAG

    grouping MRIB-MPLS-FORWARDING-BAG {
      description "MRIB mpls forwarding";
      leaf table-id {
        type uint32;
        description "Table id";
      }

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

      leaf total-label-entries {
        type uint32;
        description
          "Total number of label entries";
      }

      leaf total-s2l {
        type uint32;
        description
          "Total number of S2L sub-LSPs";
      }

      leaf head-s2l {
        type uint32;
        description "Head S2L sub-LSP";
      }

      leaf mid-s2l {
        type uint32;
        description "Mid S2L sub-LSP";
      }

      leaf tail-s2l {
        type uint32;
        description "Tail S2L sub-LSP";
      }

      leaf attribute {
        type uint32;
        description "Attribute";
      }

      leaf in-label {
        type uint32;
        description "InLabel";
      }

      leaf client {
        type uint32;
        description "Client";
      }

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

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

      leaf p2mp-id {
        type uint32;
        description "P2MP ID";
      }

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }

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

      leaf head-lsm-identifier {
        type uint32;
        description "HEAD LSM ID";
      }

      leaf e-mvpn-present {
        type boolean;
        description
          "Egress mvpn Param Present";
      }

      leaf e-vpls-present {
        type boolean;
        description
          "Egress vpls Param Present";
      }

      leaf e-encap-present {
        type boolean;
        description
          "Egress mvpn Encap Param Present";
      }

      leaf e-peek {
        type boolean;
        description "Egress Peek";
      }

      leaf i-drop {
        type boolean;
        description "Ingress Drop";
      }

      leaf e-drop {
        type boolean;
        description "Egress Drop";
      }

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

      leaf encap-id {
        type uint32;
        description "Egress ENCAP ID";
      }

      leaf id-value {
        type uint32;
        description "Egress ENCAP ID VALUE";
      }

      leaf id-type {
        type uint32;
        description
          "Egress ENCAP TYPE VALUE";
      }

      leaf assoc-tid4 {
        type uint32;
        description "Associated Table ID v4";
      }

      leaf assoc-tid6 {
        type uint32;
        description "Associated Table ID v6";
      }

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

      leaf p2mp-pw-flags {
        type uint16;
        description "P2MP PW Flags";
      }

      leaf re-serv-e {
        type yang:hex-string;
        description "RESV";
      }

      leaf bridge-id {
        type uint32;
        description "Bridge Id";
      }

      leaf shg-id {
        type uint32;
        description "SHG ID";
      }

      leaf sub-ifh {
        type xr:Interface-name;
        description "SUB IFH";
      }

      leaf xc-id {
        type uint32;
        description "XC ID";
      }

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

      leaf extranet-id {
        type uint32;
        description "Ext ID";
      }

      leaf ip-look-up {
        type uint32;
        description "IP lookup";
      }

      leaf l3p-id {
        type uint32;
        description "L3PID";
      }

      leaf explicit-null {
        type uint32;
        description "Explicit Null";
      }

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

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

      leaf output-information-num {
        type uint32;
        description "OutInfo Num";
      }

      leaf annotation {
        type string;
        description "Platform annotation";
      }

      list output-info {
        description "Output Information";
        uses MRIB-MPLS-OUTINFOS-BAG;
      }  // list output-info
    }  // grouping MRIB-MPLS-FORWARDING-BAG

    grouping MRIB-CLIENT-BAG {
      description "MRIB client connection";
      leaf client-connection-id {
        type uint32;
        description "Client-connection id";
      }

      leaf client-id {
        type uint32;
        description "Client id";
      }

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

      leaf registered-table-count {
        type uint32;
        description "Registered table count";
      }

      leaf client-type {
        type Mrib-clt;
        description "Client type";
      }

      leaf client-read-state {
        type Mrib-ccb-io;
        description "Client read state";
      }

      leaf parent-id {
        type uint32;
        description "Parent id";
      }

      leaf client-name-xr {
        type string;
        description "Client name";
      }

      leaf client-instance-id {
        type string;
        description "Client instance ID";
      }

      leaf purge-delay-secs {
        type uint32;
        units "second";
        description "Purge delay [secs]";
      }

      leaf purge-remain-secs {
        type uint32;
        units "second";
        description
          "Purge time remaining [secs]";
      }

      leaf nsf-capable {
        type boolean;
        description "NSF Capable";
      }

      leaf resync-time-secs {
        type uint32;
        units "second";
        description "Resync time [secs]";
      }

      leaf nsf-restart-time-secs {
        type uint32;
        units "second";
        description
          "NSF restart time [secs]";
      }

      leaf nsf-recovery-time-secs {
        type uint32;
        units "second";
        description
          "NSF recovery time [secs]";
      }

      leaf-list nsf-interest {
        type Mrib-clt;
        description
          "Clients of NSF interest";
      }
    }  // grouping MRIB-CLIENT-BAG

    grouping MRIB-MDT-ROUTEDB-BAG {
      description "MRIB MDT route";
      container mdt-route-source-address {
        description "Source Address";
        uses MRIB-ADDRTYPE;
      }  // container mdt-route-source-address

      container mdt-route-group-address {
        description "Group Address";
        uses MRIB-ADDRTYPE;
      }  // container mdt-route-group-address

      leaf mdt-route-group-prefix-length {
        type uint16;
        description "Group prefix length";
      }

      leaf mdt-route-table-id {
        type uint32;
        description "Route TID";
      }

      leaf mdt-remote-reprograming {
        type boolean;
        description "Need Reprog";
      }
    }  // grouping MRIB-MDT-ROUTEDB-BAG

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

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

      leaf mh-reference-count {
        type uint32;
        description "MH refcnt";
      }

      leaf intranet-reference-count {
        type uint32;
        description "Intranet Refcnt";
      }

      leaf extranet-reference-count {
        type uint32;
        description "Extranet Refcnt";
      }

      leaf mdt-up-time {
        type uint64;
        description "UpTime";
      }

      list mdt-route-db {
        description "List of MDT routes";
        uses MRIB-MDT-ROUTEDB-BAG;
      }  // list mdt-route-db
    }  // grouping MRIB-MDT-IFH-BAG

    grouping MRIB-CHKPT-TABLE-STATS {
      description "MRIB chkpt table stats";
      leaf table-description {
        type string;
        description "Table description";
      }

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

      leaf is-mirrored {
        type boolean;
        description "Table mirrored";
      }

      leaf-list statistic {
        type uint32;
        description "Stats array";
      }
    }  // grouping MRIB-CHKPT-TABLE-STATS

    grouping MRIB-CHKPT-STATS {
      description "MRIB chkpt stats";
      list checkpoint-table {
        description
          "Array of chkpt table stats";
        uses MRIB-CHKPT-TABLE-STATS;
      }  // list checkpoint-table
    }  // grouping MRIB-CHKPT-STATS

    grouping MRIB-EVPN-BKT-BAG {
      description "MRIB EVPN Database";
      leaf bucket-id-xr {
        type uint32;
        description "BucketID";
      }

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

      leaf state {
        type Mrib-evpn-bucket-state;
        description "State";
      }

      leaf flags {
        type uint8;
        description "Flags";
      }

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }
    }  // grouping MRIB-EVPN-BKT-BAG

    grouping MRIB-BVI-MROUTE-BAG {
      description "MRIB BVI Mroute";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range
    }  // grouping MRIB-BVI-MROUTE-BAG

    grouping MRIB-GROUP-RNG-BAG {
      description "MRIB group-range";
      container group-prefix {
        description "Group address prefix";
        uses MRIB-ADDRTYPE;
      }  // container group-prefix

      leaf group-prefix-length {
        type uint32;
        description
          "Group address prefix length";
      }
    }  // grouping MRIB-GROUP-RNG-BAG

    grouping MRIB-ADDRTYPE {
      description "MRIB ADDRTYPE";
      leaf af-name {
        type Mrib-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 MRIB-ADDRTYPE

    grouping MRIB-BVI-ROUTE-BAG {
      description "MRIB BVI DB";
      container source {
        description "Source address";
        uses MRIB-ADDRTYPE;
      }  // container source

      container group-range {
        description "Group range";
        uses MRIB-GROUP-RNG-BAG;
      }  // container group-range

      leaf bvi-ifhandle {
        type xr:Interface-name;
        description "BVI IFhandle";
      }

      leaf bvi-platform-data-length {
        type uint8;
        units "byte";
        description "Platform data bytes";
      }

      leaf bvi-platform-data {
        type yang:hex-string;
        description "BVI platform data";
      }

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

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }

      leaf ref-count {
        type uint32;
        description "Refcount";
      }

      list mroute {
        description "Mroute";
        uses MRIB-BVI-MROUTE-BAG;
      }  // list mroute
    }  // grouping MRIB-BVI-ROUTE-BAG

    grouping MRIB-BVI-INTERFACE-BAG {
      description "MRIB BVI INTERFACE BAG";
      leaf table-id {
        type Rsi-tbl-id;
        description "Table ID";
      }

      leaf table-name {
        type string;
        description "Table Name";
      }
    }  // grouping MRIB-BVI-INTERFACE-BAG

    grouping MRIB-NSR-END-INFO {
      description "MRIB NSR END INFO";
      container event-tm {
        description "event tm";
        uses MRIB-TIMESPEC;
      }  // container event-tm

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

      leaf client-type {
        type Mrib-clt;
        description "ClientType";
      }

      leaf num-tbl-with-purged-attr {
        type uint32;
        description
          "num tbl with purged attr";
      }

      leaf num-e-with-purged-e-attr {
        type uint32;
        description
          "num e with purged e attr";
      }

      leaf num-e-with-purged-if-attr {
        type uint32;
        description
          "num e with purged if attr";
      }

      leaf num-if-with-purged-if-attr {
        type uint32;
        description
          "num if with purged if attr";
      }
    }  // grouping MRIB-NSR-END-INFO

    grouping MRIB-COFO-SUMMARY-BAG {
      description
        "Summary bag for collapsed forwarding";
      leaf local-star-g {
        type uint32;
        description
          "Number of local *,g entries in cofo";
      }

      leaf remote-star-g {
        type uint32;
        description
          "Number of remote *,g entries in cofo";
      }

      leaf local-sg {
        type uint32;
        description
          "Number of local SG entries in cofo";
      }

      leaf remote-sg {
        type uint32;
        description
          "Number of remote SG entries in cofo";
      }

      leaf local-labels {
        type uint32;
        description
          "Number of local label entries in cofo";
      }

      leaf remote-labels {
        type uint32;
        description
          "Number of remote label entries in cofo";
      }

      leaf local-encap {
        type uint32;
        description
          "Number of local encap entries in cofo";
      }

      leaf remote-encap {
        type uint32;
        description
          "Number of remote encap entries in cofo";
      }
    }  // grouping MRIB-COFO-SUMMARY-BAG

    grouping MRIB-CTID-BAG {
      description "MRIB Core Tree ID";
      leaf type {
        type Mrib-show-ctid;
        description "Type";
      }

      leaf id {
        type inet:ipv4-address;
        description "ID";
      }
    }  // grouping MRIB-CTID-BAG

    grouping LMRIB-COFO-BAG {
      description
        "LSM information exchanged for collapsed
       forwarding";
      container remote-ctid {
        description
          "The CTID of the remote label whose nodeset is
         recieved in MRIB";
        uses MRIB-CTID-BAG;
      }  // container remote-ctid

      container send-timestamp {
        description
          "Unix timestamp when local information was last
         sent to connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container send-timestamp

      container fgid-send-timestamp {
        description
          "Unix timestamp when local FGID information was
         last sent to RIB on connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container fgid-send-timestamp

      container receive-timestamp {
        description
          "Unix timestamp when information was last
         received from connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container receive-timestamp

      leaf annotation {
        type string;
        description "Platform annotation";
      }

      leaf incoming-label {
        type uint32;
        description "Incoming label info";
      }

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

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

      leaf send-count {
        type uint16;
        description
          "Number of updates sent to connected SDRs for
         this FEC";
      }

      leaf fgid-send-count {
        type uint16;
        description
          "Number of FGID updates sent to RIB on connected
         SDRs for this FEC";
      }

      leaf receive-count {
        type uint16;
        description
          "Number of updates received from connected SDRs
         for this FEC";
      }

      leaf local {
        type boolean;
        description
          "Flag set if entry has information originating
         from local SDR";
      }

      leaf remote {
        type boolean;
        description
          "Flag set if entry has information originating
         from remote SDR";
      }

      list primary-nodeset {
        description
          "Primary nodeset for update";
        uses MRIB-FAPID-BAG;
      }  // list primary-nodeset

      list backup-nodeset {
        description
          "Backup nodeset for update";
        uses MRIB-FAPID-BAG;
      }  // list backup-nodeset
    }  // grouping LMRIB-COFO-BAG

    grouping MRIB-COFO-BAG {
      description
        "IP multicast information exchanged for collapsed
       forwarding";
      container send-timestamp {
        description
          "Unix timestamp when local information was last
         sent to connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container send-timestamp

      container receive-timestamp {
        description
          "Unix timestamp when information was last
         received from connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container receive-timestamp

      leaf send-count {
        type uint16;
        description
          "Number of updates sent to connected SDRs for
         this route";
      }

      leaf receive-count {
        type uint16;
        description
          "Number of updates received from connected SDRs
         for this route";
      }

      leaf local {
        type boolean;
        description
          "Flag set if entry has information originating
         from local SDR";
      }

      leaf remote {
        type boolean;
        description
          "Flag set if entry has information originating
         from remote SDR";
      }

      list nodeset {
        description "Nodeset for update";
        uses MRIB-FAPID-BAG;
      }  // list nodeset
    }  // grouping MRIB-COFO-BAG

    grouping MRIB-TIMESPEC {
      description "MRIB TIMESPEC";
      leaf seconds {
        type uint32;
        description "Seconds";
      }

      leaf nanoseconds {
        type uint32;
        description "Nanoseconds";
      }
    }  // grouping MRIB-TIMESPEC

    grouping MRIB-FAPID-BAG {
      description "FAP ID";
      leaf fap-id {
        type string {
          length "0..32";
        }
        description "FAP ID";
      }

      leaf local {
        type boolean;
        description "Local or Remote";
      }
    }  // grouping MRIB-FAPID-BAG

    grouping MRIB-COFO-ENCAP-BAG {
      description
        "Encap ID information exchanged for collapsed
       forwarding";
      container send-timestamp {
        description
          "Unix timestamp when local information was last
         sent to connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container send-timestamp

      container receive-timestamp {
        description
          "Unix timestamp when information was last
         received from connected SDRs";
        uses MRIB-TIMESPEC;
      }  // container receive-timestamp

      leaf encap-key-length {
        type uint16;
        description "Length of Encap Key";
      }

      leaf cofo-key-complete {
        type boolean;
        description
          "TRUE indicates all LSM encap OLEs have been
         updated in the key. FALSE indicates pending
         updates to LSM encap OLEs.";
      }

      leaf encap-id-xr {
        type uint32;
        description
          "The Encap ID corresponding to the Encap Key.
         Includes 3-bits for SDR-ID (bits 21-23)";
      }

      leaf num-ol-es {
        type uint32;
        description
          "Number of OLEs in Encap entry";
      }

      leaf send-count {
        type uint16;
        description
          "Number of updates sent to connected SDRs for
         this Encap Key";
      }

      leaf receive-count {
        type uint16;
        description
          "Number of updates received from connected SDRs
         for this Encap Key";
      }

      leaf local {
        type boolean;
        description
          "Flag set if entry has information originating
         from local SDR";
      }

      leaf remote {
        type boolean;
        description
          "Flag set if entry has information originating
         from remote SDR";
      }

      list primary-nodeset {
        description
          "Primary nodeset for update";
        uses MRIB-FAPID-BAG;
      }  // list primary-nodeset

      list backup-nodeset {
        description
          "Backup nodeset for update";
        uses MRIB-FAPID-BAG;
      }  // list backup-nodeset
    }  // grouping MRIB-COFO-ENCAP-BAG

    grouping MRIB-REGDB-BAG {
      description "MRIB Regdb Entry";
      leaf registration-type {
        type int32;
        description "Regdb Type";
      }

      leaf nh-addr {
        type inet:ipv4-address;
        description "NH addr";
      }

      leaf regdb-ip-leaf-count {
        type uint32;
        description "Regdb ip Leaf Count";
      }

      leaf regdb-lbl-leaf-count {
        type uint32;
        description "Regdb label Leaf Count";
      }

      leaf regdb-mlcl-leaf-count {
        type uint32;
        description "Regdb MLC Leaf Count";
      }

      leaf reg-is-ecd-stale {
        type boolean;
        description "Regdb  ECD stale flag";
      }

      leaf reg-is-ecd-reg {
        type boolean;
        description
          "Regdb  ECD is registered";
      }

      leaf notification-count {
        type uint32;
        description
          "Count of notifications from fib_mgr ";
      }

      leaf dest-vrf-name {
        type string;
        description "Destination Vrf Name";
      }
    }  // grouping MRIB-REGDB-BAG
  }  // submodule Cisco-IOS-XR-mrib-oper-sub1