Cisco-IOS-XR-mfwd-oper

This module contains a collection of YANG definitions for Cisco IOS-XR mfwd package operational data. This module contains defi...

  • Version: 2020-10-11

    Cisco-IOS-XR-mfwd-oper@2020-10-11


    
      module Cisco-IOS-XR-mfwd-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-mfwd-oper";
    
        prefix mfwd-oper;
    
        import ietf-inet-types {
          prefix inet;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-mfwd-oper-sub2 {
          revision-date "2020-10-11";
        }
        include Cisco-IOS-XR-mfwd-oper-sub1 {
          revision-date "2020-10-11";
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
    Customer Service
    
    Postal: 170 West Tasman Drive
    San Jose, CA 95134
    
    Tel: +1 800 553-NETS
    
    E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
    for Cisco IOS-XR mfwd package operational data.
    
    This module contains definitions
    for the following management objects:
      mfwd: MFWD operational data
      ipv6-mfwd: IPV6 MFWD operational data
    
    Copyright (c) 2013-2020 by Cisco Systems, Inc.
    All rights reserved.";
    
        revision "2020-10-11" {
          description
            "Backward compatible addition in leaf ul-interface, customer-mdt-data-tree-sidacl-name, is-customer-mdt-data-tree-sidacl-present and ,is-all-customer-routes-for-tree-sid-data-mdt";
        }
    
        revision "2019-08-27" {
          description
            "Initial IOS-XR MFWD native model";
        }
    
        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 Encap {
          type enumeration {
            enum "any" {
              value 0;
              description "Encap Any";
            }
            enum "lsm" {
              value 1;
              description "Encap LSM";
            }
            enum "te" {
              value 2;
              description "Encap TE";
            }
            enum "gre" {
              value 3;
              description "Encap GRE";
            }
          }
          description "Encap";
        }
    
        container mfwd {
          config false;
          description "MFWD operational data";
          container nodes {
            description "All Nodes";
            list node {
              key "node-name";
              description
                "Multicast Forwarding operational data for this
    particular node";
              container process {
                description "MFWD NSF Databases";
                container nsf {
                  description
                    "MFWD NSF Information";
                  leaf multicast-nsf {
                    type Ipv4-mfwd-nsf-modes;
                    units "second";
                    description
                      "Multicast NSF state in secs";
                  }
    
                  leaf multicast-nsf-time-left {
                    type uint32;
                    units "second";
                    description
                      "Multicast NSF time remaining in secs";
                  }
    
                  leaf ifcnsf {
                    type boolean;
                    description "IFC NSF state";
                  }
                }  // container nsf
    
                container vrfs {
                  description
                    "Traversal in VRF Name/ID DB";
                  list vrf {
                    key "vrf-name";
                    description "VRF";
                    leaf vrf-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description "VRF Name";
                    }
    
                    container mdt-default-source {
                      description
                        "Default MDT Source address";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-source
    
                    container mdt-default-group-prefix {
                      description
                        "Default MDT Group address prefix";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-group-prefix
    
                    leaf rsi-table-name {
                      type string;
                      description
                        "RSI Table Name";
                    }
    
                    leaf rsi-table-id {
                      type uint32;
                      description "RSI Table ID";
                    }
    
                    leaf vrf-id {
                      type uint32;
                      description "RSI VRF ID";
                    }
    
                    leaf vr-id {
                      type uint32;
                      description "RSI VR ID";
                    }
    
                    leaf is-table-active {
                      type boolean;
                      description
                        "Is Table active?";
                    }
    
                    leaf previous-rsi-table-id {
                      type uint32;
                      description
                        "Previous RSI Table ID";
                    }
    
                    leaf is-linked {
                      type boolean;
                      description
                        "Is linked to sibling table?";
                    }
    
                    leaf table-type {
                      type uint8;
                      description "table type";
                    }
    
                    leaf table-location {
                      type Ipv4-mfwd-tbl-location;
                      description
                        "table location";
                    }
    
                    leaf local-interface-count {
                      type uint32;
                      description
                        "Table local intf count";
                    }
    
                    leaf route-count {
                      type uint32;
                      description
                        "Total route count";
                    }
    
                    leaf mdt-default-group-prefix-length {
                      type uint16;
                      description
                        "Default MDT Group address prefix length";
                    }
    
                    leaf mdt-interface {
                      type xr:Interface-name;
                      description
                        "MDT Interface handle";
                    }
    
                    leaf mldp-mdt-interface {
                      type xr:Interface-name;
                      description
                        "MLDP MDT Interface handle";
                    }
    
                    leaf inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "Inband MDT Interface handle";
                    }
    
                    leaf star-g-inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "StarG Inband MDT Interface handle";
                    }
    
                    leaf p2mpte-mdt-interface {
                      type xr:Interface-name;
                      description
                        "P2MPTE MDT Interface handle";
                    }
    
                    leaf ir-mdt-interface {
                      type xr:Interface-name;
                      description
                        "IR MDT Interface handle";
                    }
    
                    leaf tr-mdt-interface {
                      type xr:Interface-name;
                      description
                        "TreeSID MDT Interface handle";
                    }
    
                    leaf mldp-mdt-turnaround {
                      type boolean;
                      description
                        "MLDP MDT Turnaround";
                    }
    
                    leaf p2mpte-mdt-turnaround {
                      type boolean;
                      description
                        "P2MPTE MDT Turnaround";
                    }
    
                    leaf ir-mdt-turnaround {
                      type boolean;
                      description
                        "IR MDT Turnaround";
                    }
    
                    leaf tr-mdt-turnaround {
                      type boolean;
                      description
                        "TreeSID MDT Turnaround";
                    }
    
                    leaf mdt-interface-count {
                      type uint32;
                      description
                        "No of routes using MDT handle";
                    }
    
                    leaf is-mdt-master-linecard {
                      type boolean;
                      description
                        "Is this Master LC table";
                    }
    
                    leaf local-egress-count {
                      type uint32;
                      description
                        "No of local egress interfaces";
                    }
    
                    leaf loopback {
                      type xr:Interface-name;
                      description
                        "Loopback interface handle";
                    }
    
                    leaf customer-mdt-data-acl-name {
                      type string;
                      description
                        "Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-mldpacl-name {
                      type string;
                      description
                        "MLDP Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-p2mpteacl-name {
                      type string;
                      description
                        "P2MPTE Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-iracl-name {
                      type string;
                      description
                        "IR Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-tree-sidacl-name {
                      type string;
                      description
                        "Tree-SID Data MDT ACL Name for customer vrf";
                    }
    
                    leaf is-customer-mdt-data-acl-present {
                      type boolean;
                      description
                        "Is Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-mldpacl-present {
                      type boolean;
                      description
                        "Is MLDP Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-p2mpteacl-present {
                      type boolean;
                      description
                        "Is P2MPTE Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-iracl-present {
                      type boolean;
                      description
                        "Is IR Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-tree-sidacl-present {
                      type boolean;
                      description
                        "Is Tree-SID Data MDT ACL present";
                    }
    
                    leaf data-mdt-threshold {
                      type uint32;
                      description
                        "Data MDT Threshold";
                    }
    
                    leaf is-all-customer-routes-for-data-mdt {
                      type boolean;
                      description
                        "All customer routes for data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-mldp-data-mdt {
                      type boolean;
                      description
                        "All customer routes for MLDP data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-p2mpte-data-mdt {
                      type boolean;
                      description
                        "All customer routes for P2MPTE data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-ir-data-mdt {
                      type boolean;
                      description
                        "All customer routes for IR data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-tree-sid-data-mdt {
                      type boolean;
                      description
                        "All customer routes for Tree-SID data mdt ?";
                    }
    
                    leaf extranet-child-route-count {
                      type uint32;
                      description
                        "Number of child extranet routes";
                    }
                  }  // list vrf
                }  // container vrfs
    
                container table-ids {
                  description
                    "Traversal using Table ID DB";
                  list table-id {
                    key "table-id";
                    description "Table ID";
                    leaf table-id {
                      type uint32;
                      description "Table ID";
                    }
    
                    container mdt-default-source {
                      description
                        "Default MDT Source address";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-source
    
                    container mdt-default-group-prefix {
                      description
                        "Default MDT Group address prefix";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-group-prefix
    
                    leaf rsi-table-name {
                      type string;
                      description
                        "RSI Table Name";
                    }
    
                    leaf rsi-table-id {
                      type uint32;
                      description "RSI Table ID";
                    }
    
                    leaf vrf-id {
                      type uint32;
                      description "RSI VRF ID";
                    }
    
                    leaf vr-id {
                      type uint32;
                      description "RSI VR ID";
                    }
    
                    leaf is-table-active {
                      type boolean;
                      description
                        "Is Table active?";
                    }
    
                    leaf previous-rsi-table-id {
                      type uint32;
                      description
                        "Previous RSI Table ID";
                    }
    
                    leaf is-linked {
                      type boolean;
                      description
                        "Is linked to sibling table?";
                    }
    
                    leaf table-type {
                      type uint8;
                      description "table type";
                    }
    
                    leaf table-location {
                      type Ipv4-mfwd-tbl-location;
                      description
                        "table location";
                    }
    
                    leaf local-interface-count {
                      type uint32;
                      description
                        "Table local intf count";
                    }
    
                    leaf route-count {
                      type uint32;
                      description
                        "Total route count";
                    }
    
                    leaf mdt-default-group-prefix-length {
                      type uint16;
                      description
                        "Default MDT Group address prefix length";
                    }
    
                    leaf mdt-interface {
                      type xr:Interface-name;
                      description
                        "MDT Interface handle";
                    }
    
                    leaf mldp-mdt-interface {
                      type xr:Interface-name;
                      description
                        "MLDP MDT Interface handle";
                    }
    
                    leaf inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "Inband MDT Interface handle";
                    }
    
                    leaf star-g-inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "StarG Inband MDT Interface handle";
                    }
    
                    leaf p2mpte-mdt-interface {
                      type xr:Interface-name;
                      description
                        "P2MPTE MDT Interface handle";
                    }
    
                    leaf ir-mdt-interface {
                      type xr:Interface-name;
                      description
                        "IR MDT Interface handle";
                    }
    
                    leaf tr-mdt-interface {
                      type xr:Interface-name;
                      description
                        "TreeSID MDT Interface handle";
                    }
    
                    leaf mldp-mdt-turnaround {
                      type boolean;
                      description
                        "MLDP MDT Turnaround";
                    }
    
                    leaf p2mpte-mdt-turnaround {
                      type boolean;
                      description
                        "P2MPTE MDT Turnaround";
                    }
    
                    leaf ir-mdt-turnaround {
                      type boolean;
                      description
                        "IR MDT Turnaround";
                    }
    
                    leaf tr-mdt-turnaround {
                      type boolean;
                      description
                        "TreeSID MDT Turnaround";
                    }
    
                    leaf mdt-interface-count {
                      type uint32;
                      description
                        "No of routes using MDT handle";
                    }
    
                    leaf is-mdt-master-linecard {
                      type boolean;
                      description
                        "Is this Master LC table";
                    }
    
                    leaf local-egress-count {
                      type uint32;
                      description
                        "No of local egress interfaces";
                    }
    
                    leaf loopback {
                      type xr:Interface-name;
                      description
                        "Loopback interface handle";
                    }
    
                    leaf customer-mdt-data-acl-name {
                      type string;
                      description
                        "Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-mldpacl-name {
                      type string;
                      description
                        "MLDP Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-p2mpteacl-name {
                      type string;
                      description
                        "P2MPTE Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-iracl-name {
                      type string;
                      description
                        "IR Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-tree-sidacl-name {
                      type string;
                      description
                        "Tree-SID Data MDT ACL Name for customer vrf";
                    }
    
                    leaf is-customer-mdt-data-acl-present {
                      type boolean;
                      description
                        "Is Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-mldpacl-present {
                      type boolean;
                      description
                        "Is MLDP Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-p2mpteacl-present {
                      type boolean;
                      description
                        "Is P2MPTE Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-iracl-present {
                      type boolean;
                      description
                        "Is IR Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-tree-sidacl-present {
                      type boolean;
                      description
                        "Is Tree-SID Data MDT ACL present";
                    }
    
                    leaf data-mdt-threshold {
                      type uint32;
                      description
                        "Data MDT Threshold";
                    }
    
                    leaf is-all-customer-routes-for-data-mdt {
                      type boolean;
                      description
                        "All customer routes for data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-mldp-data-mdt {
                      type boolean;
                      description
                        "All customer routes for MLDP data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-p2mpte-data-mdt {
                      type boolean;
                      description
                        "All customer routes for P2MPTE data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-ir-data-mdt {
                      type boolean;
                      description
                        "All customer routes for IR data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-tree-sid-data-mdt {
                      type boolean;
                      description
                        "All customer routes for Tree-SID data mdt ?";
                    }
    
                    leaf extranet-child-route-count {
                      type uint32;
                      description
                        "Number of child extranet routes";
                    }
                  }  // list table-id
                }  // container table-ids
    
                container bvi-routes {
                  description
                    "MFWD BVI route table";
                  list bvi-route {
                    key "interface-name source-address group-address prefix-length";
                    description
                      "MFWD BVI route entry";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Interface Name";
                    }
    
                    leaf source-address {
                      type inet:ip-address-no-zone;
                      description
                        "Source Address";
                    }
    
                    leaf group-address {
                      type inet:ip-address-no-zone;
                      description
                        "Group Address";
                    }
    
                    leaf prefix-length {
                      type uint32;
                      description
                        "Prefix Length";
                    }
    
                    container source {
                      description
                        "Source address";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container source
    
                    container group-prefix {
                      description
                        "Group address prefix";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container group-prefix
    
                    container orig-source {
                      description
                        "Orig Source address";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container orig-source
    
                    leaf group-prefix-length {
                      type uint8;
                      description
                        "Group address prefix length";
                    }
    
                    leaf bvi-interface {
                      type xr:Interface-name;
                      description
                        "BVI interface";
                    }
    
                    leaf table-name {
                      type string;
                      description "Table Name";
                    }
    
                    leaf uptime {
                      type uint64;
                      description
                        "Time entry has been active";
                    }
    
                    list mroute {
                      description "MRoute";
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      leaf group-prefix-length {
                        type uint8;
                        description
                          "Group address prefix length";
                      }
                    }  // list mroute
                  }  // list bvi-route
                }  // container bvi-routes
              }  // container process
    
              container databases {
                description "MFWD Databases";
                list database {
                  key "database-name";
                  description "Database Name";
                  container encap-registrations {
                    description
                      "MFWD Encap Registration";
                    list encap-registration {
                      key "encap-type lsm-id if-handle source-address group-address";
                      description
                        "MFWD Encap Registration";
                      leaf encap-type {
                        type Encap;
                        description "Encap Type";
                      }
    
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf if-handle {
                        type uint32;
                        description "IFHandle";
                      }
    
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      container registration-type {
                        description "Regdb Type";
                        container reg-dblsm {
                          when
                            "../type = 'lsmid'" {
                            description
                              "../Type = 'lsmid'";
                          }
                          description "LSM Type";
                          leaf lsm-id {
                            type uint32;
                            description
                              "Core LSM ID";
                          }
    
                          leaf reg-is-ecd-stale {
                            type boolean;
                            description
                              "encap reg ECD stale flag";
                          }
    
                          leaf reg-is-ecd-reg {
                            type boolean;
                            description
                              "Encap reg ECD is registered";
                          }
                        }  // container reg-dblsm
    
                        container reg-dbte {
                          when
                            "../type = 'teifh'" {
                            description
                              "../Type = 'teifh'";
                          }
                          description "TE Type";
                          leaf te-ifhandle {
                            type xr:Interface-name;
                            description
                              "Core TE Ifhandle";
                          }
    
                          leaf reg-is-ecd-stale {
                            type boolean;
                            description
                              "Encap reg ECD stale flag";
                          }
    
                          leaf reg-is-ecd-reg {
                            type boolean;
                            description
                              "Encap reg ECD is registered";
                          }
                        }  // container reg-dbte
    
                        container reg-dbgre {
                          when "../type = 'gre'" {
                            description
                              "../Type = 'gre'";
                          }
                          description "GRE Type";
                          container source-address {
                            description
                              "Core Source address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container source-address
    
                          container group-address {
                            description
                              "Core Group address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container group-address
    
                          leaf is-gre-core-valid {
                            type boolean;
                            description
                              "Is GRE Core Valid";
                          }
                        }  // container reg-dbgre
    
                        container reg-dbnh {
                          when "../type = 'nh'" {
                            description
                              "../Type = 'nh'";
                          }
                          description "NH Type";
                          leaf next-hop {
                            type inet:ipv4-address;
                            description
                              "Next hop address";
                          }
                        }  // container reg-dbnh
    
                        container reg-dbtimofrr {
                          when
                            "../type = 'timofrr'" {
                            description
                              "../Type = 'timofrr'";
                          }
                          description
                            "TIMOFRR TYPE";
                          container source-address {
                            description
                              "Core Source address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container source-address
    
                          container group-address {
                            description
                              "Core Group address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container group-address
    
                          leaf is-timofrr-core-valid {
                            type boolean;
                            description
                              "Is TI MOFRR Core Valid";
                          }
                        }  // container reg-dbtimofrr
    
                        leaf type {
                          type Ipv4-mfwd-show-encap;
                          description "Type";
                        }
                      }  // container registration-type
    
                      leaf registration-if-handle {
                        type xr:Interface-name;
                        description
                          "Regdb Ifhandle";
                      }
    
                      leaf encap-leaf-count {
                        type uint32;
                        description
                          "Encap Leaf Count";
                      }
                    }  // list encap-registration
                  }  // container encap-registrations
    
                  container summary {
                    description
                      "MFWD RouteDB Summary Information";
                    leaf groutes-count {
                      type uint32;
                      description
                        "No. of (*,G) routes";
                    }
    
                    leaf sg-routes-count {
                      type uint32;
                      description
                        "No. of (S,G) routes";
                    }
    
                    leaf groutes-stale-count {
                      type uint32;
                      description
                        "No. of stale (*,G) routes";
                    }
    
                    leaf sg-routes-stale-count {
                      type uint32;
                      description
                        "No. of stale (S,G) routes";
                    }
    
                    leaf groutes-incomplete-count {
                      type uint32;
                      description
                        "No. of incomplete (*,G) routes";
                    }
    
                    leaf sg-routes-incomplete-count {
                      type uint32;
                      description
                        "No. of incomplete (S,G) routes";
                    }
                  }  // container summary
    
                  container encap-identifiers {
                    description
                      "MFWD Encap Table";
                    list encap-identifier {
                      key "encap-id";
                      description
                        "MFWD Encap Identifier";
                      leaf encap-id {
                        type uint32;
                        description "Encap ID";
                      }
    
                      leaf encap-id-xr {
                        type uint32;
                        description "Encap ID";
                      }
    
                      leaf stale-flag {
                        type boolean;
                        description "Stale flag";
                      }
    
                      leaf encap-lookup-flag {
                        type boolean;
                        description
                          "IP Lookup flag";
                      }
    
                      leaf encap-route-count {
                        type uint32;
                        description
                          "Number of Routes using this Encap";
                      }
    
                      leaf interface-e-gcount {
                        type uint32;
                        description
                          "Number of egress interfaces using this encapid";
                      }
    
                      leaf interface-eg-from-v6 {
                        type boolean;
                        description
                          "Egress interfaces indicated by V6";
                      }
    
                      leaf leaf-count {
                        type uint32;
                        description
                          "Number of Encap OLEs";
                      }
    
                      leaf vr-flite-flag {
                        type boolean;
                        description
                          "MRIB Update VRFLite";
                      }
    
                      leaf v6vr-flite-flag {
                        type boolean;
                        description
                          "MRIB Update v6 VRF lite";
                      }
    
                      list leave {
                        description
                          "Encap Leafs";
                        container type {
                          description
                            "Encap Leaf Type";
                          container encap-gre {
                            when
                              "../type = 'gre'" {
                              description
                                "../Type = 'gre'";
                            }
                            description "GRE";
                            container source-address {
                              description
                                "Core Source address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container source-address
    
                            container group-address {
                              description
                                "Core Group address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container group-address
                          }  // container encap-gre
    
                          container encap-nh {
                            when
                              "../type = 'nh'" {
                              description
                                "../Type = 'nh'";
                            }
                            description "NH";
                            leaf next-hop {
                              type inet:ipv4-address;
                              description
                                "Next hop address";
                            }
                          }  // container encap-nh
    
                          container encap-timofrr {
                            when
                              "../type = 'timofrr'" {
                              description
                                "../Type = 'timofrr'";
                            }
                            description
                              "TIMOFRR";
                            container source-address {
                              description
                                "Core Source address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container source-address
    
                            container group-address {
                              description
                                "Core Group address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container group-address
                          }  // container encap-timofrr
    
                          leaf type {
                            type Ipv4-mfwd-show-encap;
                            description "Type";
                          }
    
                          leaf lsm-id {
                            when
                              "../type = 'lsmid'" {
                              description
                                "../Type = 'lsmid'";
                            }
                            type uint32;
                            description
                              "Core LSM ID";
                          }
    
                          leaf te-ifhandle {
                            when
                              "../type = 'teifh'" {
                              description
                                "../Type = 'teifh'";
                            }
                            type xr:Interface-name;
                            description
                              "Core TE Ifhandle";
                          }
                        }  // container type
    
                        leaf leaf-tr {
                          type boolean;
                          description
                            "Encap Leaf Turnaround";
                        }
                      }  // list leave
                    }  // list encap-identifier
                  }  // container encap-identifiers
    
                  container detail-interfaces {
                    description
                      "Detailed information about MFWD Interfaces";
                    list detail-interface {
                      key "interface-name";
                      description
                        "Detailed MFWD Interface info";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      container interface-info {
                        description
                          "Basic interface information";
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface Handle";
                        }
    
                        leaf is-interface-local {
                          type boolean;
                          description
                            "Is interface local to the node ?";
                        }
    
                        leaf multicast-packets-in {
                          type uint64;
                          description
                            "No. of multicast packets in";
                        }
    
                        leaf multicast-packets-out {
                          type uint64;
                          description
                            "No. of multicast packets out";
                        }
    
                        leaf ttl-threshold {
                          type uint8;
                          description
                            "Multicast TTL threshold";
                        }
    
                        leaf referencecount {
                          type uint32;
                          description
                            "Referencecount of times this interface is
    referenced";
                        }
    
                        leaf is-multicast-interface-enabled {
                          type boolean;
                          description
                            "Is interface multicast enabled";
                        }
                      }  // container interface-info
    
                      container tunnel-info {
                        description
                          "Tunnel interface information";
                        leaf is-active-tunnel {
                          type boolean;
                          description
                            "Is this interface an active tunnel";
                        }
                      }  // container tunnel-info
    
                      container bundle-info {
                        description
                          "Bundle interface information";
                        leaf bundle-member-count {
                          type uint32;
                          description
                            "No. of bundle members";
                        }
    
                        list member {
                          description
                            "List of currently local and active members of
    the bundle";
                          leaf interface {
                            type xr:Interface-name;
                            description
                              "Interface";
                          }
    
                          leaf ul-identifier {
                            type If-ul-id;
                            description "UL ID";
                          }
                        }  // list member
                      }  // container bundle-info
    
                      leaf interface {
                        type xr:Interface-name;
                        description
                          "Interface Handle";
                      }
    
                      leaf vrf-id {
                        type uint32;
                        description "RSI VRF ID";
                      }
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf route-count {
                        type uint32;
                        description
                          "No of routes associated with this interface";
                      }
    
                      leaf is-explicit-enable {
                        type boolean;
                        description
                          "Is multicast explicitly enabled on the interface";
                      }
    
                      leaf boundary-acl-name {
                        type string;
                        description
                          "Boundary ACL";
                      }
    
                      leaf type {
                        type Ipv4-mfwd-idb-intf;
                        description
                          "Interface type";
                      }
    
                      leaf is-multicast-adjacency-present {
                        type boolean;
                        description
                          "Is adjacency known on this interface ?";
                      }
    
                      leaf create-status {
                        type Ipv4-mfwd-intf-create-state;
                        description
                          "The create status of this interface";
                      }
    
                      leaf bundle-parent {
                        type xr:Interface-name;
                        description
                          "Bundle I/F if this I/F is member of the bundle";
                      }
    
                      leaf underlying-interface {
                        type xr:Interface-name;
                        description
                          "Underlying interface";
                      }
    
                      leaf mdt-mtu {
                        type uint32;
                        description "MDT MTU";
                      }
    
                      leaf remote-mdt-mtu {
                        type uint32;
                        description
                          "Remote MDT MTU";
                      }
    
                      leaf special-referencecount {
                        type uint32;
                        description
                          "Count of Special Updates using this MDT
    interface";
                      }
    
                      leaf mh-referencecount {
                        type uint32;
                        description
                          "Count of Core routes with MH flag & using this
    MDT interface";
                      }
    
                      leaf mi-referencecount {
                        type uint32;
                        description
                          "Count of VRF routes with MI flag MDT interface";
                      }
    
                      leaf is-data-plane-local {
                        type boolean;
                        description
                          "Is the dataplane for this interface local ?";
                      }
    
                      leaf mcast-intf-config-vrf-set {
                        type boolean;
                        description
                          "Multicast Interface configuration VRF present";
                      }
    
                      leaf mcast-intf-config-vrf-error {
                        type boolean;
                        description
                          "Multicast Interface configuration VRF error";
                      }
    
                      leaf mcast-intf-config-vrf-name {
                        type string;
                        description
                          "Multicast Interface configuration VRF Name";
                      }
    
                      leaf in-name-tree {
                        type boolean;
                        description
                          "Is interface present in global name tree";
                      }
    
                      leaf learned-via-gsp {
                        type boolean;
                        description
                          "Is interface learned via gsp";
                      }
    
                      leaf stale-im {
                        type boolean;
                        description
                          "Does interface has stale im info";
                      }
    
                      leaf intf-flag {
                        type uint8;
                        description
                          "Interface flag";
                      }
                    }  // list detail-interface
                  }  // container detail-interfaces
    
                  container interface-routes {
                    description
                      "Display MFIB interface specific information";
                    list interface-route {
                      key "interface-name";
                      description
                        "Interface Table";
                      container source-group-addresses {
                        description
                          "Source,Group Address Table";
                        list source-group-address {
                          key "source-address group-address prefix-length";
                          description
                            "List the routes associated with an
    Interface";
                          leaf source-address {
                            type inet:ip-address-no-zone;
                            description
                              "Source Address";
                          }
    
                          leaf group-address {
                            type inet:ip-address-no-zone;
                            description
                              "Group Address";
                          }
    
                          leaf prefix-length {
                            type uint32 {
                              range "0..128";
                            }
                            description
                              "Prefix Length";
                          }
    
                          container source {
                            description
                              "Source address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container source
    
                          container group-prefix {
                            description
                              "Group address prefix";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container group-prefix
    
                          container orig-source {
                            description
                              "Orig source address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container orig-source
    
                          container entry-attributes {
                            description
                              "Routing entry attributes";
                            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 information";
                            }
    
                            leaf is-inherit-from-set {
                              type boolean;
                              description
                                "Inherit from information";
                            }
    
                            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-unicast-nsf-on {
                              type boolean;
                              description
                                "Unicast NSF flag";
                            }
    
                            leaf is-mdt-encapsulation-on {
                              type boolean;
                              description
                                "MDT Encapsulation flag";
                            }
    
                            leaf is-mdt-decapsulation-on {
                              type boolean;
                              description
                                "MDT Decapsulation flag";
                            }
    
                            leaf is-mdt-address-on {
                              type boolean;
                              description
                                "MDT Address flag";
                            }
    
                            leaf is-threshold-crossed {
                              type boolean;
                              description
                                "Data MDT Threshold Crossed";
                            }
    
                            leaf is-mdt-handle-set {
                              type boolean;
                              description
                                "MDT Handle flag";
                            }
    
                            leaf is-conditional-decapsulation {
                              type boolean;
                              description
                                "Conditional Decapsulation flag";
                            }
    
                            leaf is-packet-decapsulation-true {
                              type boolean;
                              description
                                "Should we decapsulation pkt";
                            }
    
                            leaf is-packet-decapsulation-true-v6 {
                              type boolean;
                              description
                                "decapsulation pkt with v6 payload";
                            }
    
                            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 flag";
                            }
    
                            leaf encapsulation-identifier {
                              type boolean;
                              description
                                "Encap-id present";
                            }
    
                            leaf rpf-identifier {
                              type boolean;
                              description
                                "RPF-id present";
                            }
    
                            leaf mo-frr-enabled {
                              type boolean;
                              description
                                "MoFRR Enable";
                            }
    
                            leaf mo-frr-state {
                              type boolean;
                              description
                                "MOFRR State";
                            }
    
                            leaf mo-frr-primary {
                              type boolean;
                              description
                                "MOFRR Primary";
                            }
    
                            leaf mo-frr-backup {
                              type boolean;
                              description
                                "MOFRR Backup";
                            }
    
                            leaf amt {
                              type boolean;
                              description
                                "AMT State";
                            }
    
                            leaf vx-lan {
                              type boolean;
                              description
                                "VxLAN State";
                            }
                          }  // container entry-attributes
    
                          container parent-group-prefix {
                            description
                              "Inherit from Group address prefix";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container parent-group-prefix
    
                          container lsm-rpf-address {
                            description
                              "LSM RPF Address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container lsm-rpf-address
    
                          container mdt-default-source {
                            description
                              "Source address";
                            leaf id-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "IDType";
                            }
    
                            leaf ipv4-mdt-address {
                              when
                                "../id-type = 'ipv4'" {
                                description
                                  "../IDType = 'IPv4'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 Addr";
                            }
    
                            leaf id {
                              when
                                "../id-type = 'any'" {
                                description
                                  "../IDType = 'Any'";
                              }
                              type uint32;
                              description "ID";
                            }
    
                            leaf ipv6-mdt-address {
                              when
                                "../id-type = 'ipv6'" {
                                description
                                  "../IDType = 'IPv6'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv6 Addr";
                            }
                          }  // container mdt-default-source
    
                          container mdt-default-group-prefix {
                            description
                              "Group address prefix";
                            leaf id-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "IDType";
                            }
    
                            leaf ipv4-mdt-address {
                              when
                                "../id-type = 'ipv4'" {
                                description
                                  "../IDType = 'IPv4'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 Addr";
                            }
    
                            leaf id {
                              when
                                "../id-type = 'any'" {
                                description
                                  "../IDType = 'Any'";
                              }
                              type uint32;
                              description "ID";
                            }
    
                            leaf ipv6-mdt-address {
                              when
                                "../id-type = 'ipv6'" {
                                description
                                  "../IDType = 'IPv6'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv6 Addr";
                            }
                          }  // container mdt-default-group-prefix
    
                          leaf rsi-table-id {
                            type uint32;
                            description
                              "RSI Table ID";
                          }
    
                          leaf group-prefix-length {
                            type uint16;
                            description
                              "Group address prefix length";
                          }
    
                          leaf route-version {
                            type uint16;
                            description
                              "Route version";
                          }
    
                          leaf stale-route {
                            type boolean;
                            description
                              "The route is stale";
                          }
    
                          leaf incomplete-route {
                            type boolean;
                            description
                              "The route is incomplete";
                          }
    
                          leaf time-last-used {
                            type string;
                            description
                              "Last time entry was used";
                          }
    
                          leaf bytes-out {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes out";
                          }
    
                          leaf bytes-rep {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes replicated";
                          }
    
                          leaf packets-in {
                            type uint32;
                            description
                              "No of packets in";
                          }
    
                          leaf packets-out {
                            type uint32;
                            description
                              "No of packets out";
                          }
    
                          leaf packets-rep {
                            type uint32;
                            description
                              "No of packets replicated";
                          }
    
                          leaf packets-failed-rpf {
                            type uint32;
                            description
                              "No of packets which failed rpf";
                          }
    
                          leaf packets-failed-ttl {
                            type uint32;
                            description
                              "No of packets which failed TTL check";
                          }
    
                          leaf outgoing-list-failure-packets {
                            type uint32;
                            description
                              "No of packets dropped due to null olist";
                          }
    
                          leaf encapsulation-ratelimit-drops {
                            type uint32;
                            description
                              "No of encap packets dropped/ratelimited";
                          }
    
                          leaf other-failures {
                            type uint32;
                            description
                              "No of packets dropped due to misc failures";
                          }
    
                          leaf hardware-ingress-packets-in {
                            type uint64;
                            description
                              "No of packets input at ingress metro";
                          }
    
                          leaf hardware-ingress-bytes-in {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes input on this interface";
                          }
    
                          leaf hardware-ingres-packets-drop {
                            type uint64;
                            description
                              "No of packets dropped at ingress metro";
                          }
    
                          leaf hardware-egress-packets-out {
                            type uint64;
                            description
                              "No of packets sent out at egress metro";
                          }
    
                          leaf hardware-egress-packets-rep {
                            type uint64;
                            description
                              "No of packets replicated at egress metro";
                          }
    
                          leaf hardware-egress-packets-drop {
                            type uint64;
                            description
                              "No of packets dropped at egress metro";
                          }
    
                          leaf hardware-egress-byte-out {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes sent out at egress metro";
                          }
    
                          leaf hardware-egress-byte-rep {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes replicated at egress metro";
                          }
    
                          leaf is-hardware-ingress-input-counter-valid {
                            type boolean;
                            description
                              "Is input counter at ingress metro valid ?";
                          }
    
                          leaf is-hardware-ingress-drop-counter-valid {
                            type boolean;
                            description
                              "Is drop counter at ingress metro valid ?";
                          }
    
                          leaf is-hardware-ingress-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-output-counter-valid {
                            type boolean;
                            description
                              "Is output counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-replicate-counter-valid {
                            type boolean;
                            description
                              "Is replicated counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-drop-counter-valid {
                            type boolean;
                            description
                              "Is drop counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-fwd-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-rep-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes replicated counter at egress metro
    valid ?";
                          }
    
                          leaf parent-group-prefix-length {
                            type uint16;
                            description
                              "Inherit from Group address prefix length";
                          }
    
                          leaf mo-frr-active {
                            type boolean;
                            description
                              "MoFRR Active";
                          }
    
                          leaf mo-frr-sequence-number {
                            type uint32;
                            description
                              "MoFRR Sequence Number";
                          }
    
                          leaf new-mo-frr-active {
                            type boolean;
                            description
                              "New MoFRR Active";
                          }
    
                          leaf new-mo-frr-sequence-number {
                            type uint32;
                            description
                              "New MoFRR Sequence Number";
                          }
    
                          leaf mo-frrhw-event {
                            type boolean;
                            description
                              "Is this an MoFRR Hardware Event";
                          }
    
                          leaf mdt-interface {
                            type xr:Interface-name;
                            description
                              "MDT Interface";
                          }
    
                          leaf is-mdt-encapsulation-info {
                            type boolean;
                            description
                              "MDT Encap information";
                          }
    
                          leaf mdt-default-group-prefix-length {
                            type uint16;
                            description
                              "Group address prefix length";
                          }
    
                          leaf mdt-associated-table-id {
                            type uint32;
                            description
                              "Associated Table (vrf or Core)";
                          }
    
                          leaf mdt-associated-remote-table-id {
                            type uint32;
                            description
                              "Associated Remote Table (vrf or Core)";
                          }
    
                          leaf is-mdt-data-rate-probe {
                            type boolean;
                            description
                              "Are we probing for rate for Data MDT ?";
                          }
    
                          leaf is-mdt-data-rate-in-list {
                            type boolean;
                            description
                              "Are we in the list for rate calc for Data MDT ?";
                          }
    
                          leaf is-mdt-data-rate-throttle {
                            type boolean;
                            description
                              "Is Data MDT rate calculation throttled ?";
                          }
    
                          leaf mdt-data-throttle-left {
                            type uint32;
                            description
                              "Time remaining for throttle to be removed ?";
                          }
    
                          leaf mdt-decapsulation-egress-count {
                            type uint32;
                            description
                              "No. of pkts decapped on SW egress node";
                          }
    
                          leaf mdt-encapsulation-ingress-v4-count {
                            type uint32;
                            description
                              "No. of v4 pkts encapped on SW ingress node";
                          }
    
                          leaf mdt-encapsulation-ingress-v6-count {
                            type uint32;
                            description
                              "No. of v6 pkts encapped on SW ingress node";
                          }
    
                          leaf incoming-traffic-rate {
                            type uint64;
                            description
                              "Incoming traffic rate when MDT is forwarding";
                          }
    
                          leaf is-rate-per-route {
                            type boolean;
                            description
                              "Are we doing rate per route ?";
                          }
    
                          leaf is-prefix-accounting {
                            type boolean;
                            description
                              "Are we doing stats per route ?";
                          }
    
                          leaf annotation {
                            type string;
                            description
                              "Platform annotation";
                          }
    
                          leaf is-hardware-egress-bits-per-seconds-average-rate {
                            type uint64;
                            units "bit/s";
                            description
                              "Average bps out rate";
                          }
    
                          leaf is-hardware-ingress-bits-per-seconds-average-rate {
                            type uint64;
                            units "bit/s";
                            description
                              "Average bps in rate";
                          }
    
                          leaf is-hardware-egress-packet-per-seconds-average-rate {
                            type uint64;
                            description
                              "Average pps out rate";
                          }
    
                          leaf is-hardware-ingress-packet-per-seconds-average-rate {
                            type uint64;
                            description
                              "Average pps in rate";
                          }
    
                          leaf is-hardware-egress-bytes-rate-counte-valid {
                            type boolean;
                            description
                              "Is egress bits per sec rate valid?";
                          }
    
                          leaf is-hardware-egress-packets-rate-counter-valid {
                            type boolean;
                            description
                              "Is egress packet per sec rate valid?";
                          }
    
                          leaf is-hardware-ingress-bytes-rate-counter-valid {
                            type boolean;
                            description
                              "Is ingress bits per sec rate valid?";
                          }
    
                          leaf is-hardware-ingress-packets-rate-counter-valid {
                            type boolean;
                            description
                              "Is ingress packet per sec rate valid?";
                          }
    
                          leaf uptime {
                            type uint64;
                            units "second";
                            description
                              "Uptime in seconds";
                          }
    
                          leaf rpf-table-id {
                            type uint32;
                            description
                              "RPF TID";
                          }
    
                          leaf route-e-gcount {
                            type uint16;
                            description
                              "Route EG count";
                          }
    
                          leaf route-encap-id {
                            type uint32;
                            description
                              "Encap Id";
                          }
    
                          leaf rpf-id {
                            type uint32;
                            description "RPF Id";
                          }
    
                          leaf local-receiver {
                            type boolean;
                            description
                              "Local Receiver Flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turn Around Flag";
                          }
    
                          leaf next-amt-route {
                            type uint64;
                            description
                              "Next AMT route";
                          }
    
                          leaf prev-amt-route {
                            type uint64;
                            description
                              "Prev AMT route";
                          }
    
                          leaf in-amt-route-list {
                            type boolean;
                            description
                              "Are we in the list of AMT route ?";
                          }
    
                          list interface {
                            description
                              "Interfaces";
                            container interface-attributes {
                              description
                                "Interface attributes";
                              leaf is-forward {
                                type boolean;
                                description
                                  "Forwarding flag";
                              }
    
                              leaf is-accept {
                                type boolean;
                                description
                                  "Accepting flag";
                              }
    
                              leaf is-accept-backup {
                                type boolean;
                                description
                                  "Backup Accepting flag";
                              }
    
                              leaf is-internal-copy {
                                type boolean;
                                description
                                  "Internal Copy flag";
                              }
    
                              leaf is-negate-signal {
                                type boolean;
                                description
                                  "Negate Signal";
                              }
    
                              leaf is-donot-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-encapsulated-interface {
                                type boolean;
                                description
                                  "Encapsulated interface flag";
                              }
    
                              leaf is-egress-interface {
                                type boolean;
                                description
                                  "Egress processing flag";
                              }
    
                              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-tr-mdt-interface {
                                type boolean;
                                description
                                  "TreeSID MDT Interface flag";
                              }
    
                              leaf is-mdt-data-triggered {
                                type boolean;
                                description
                                  "Data MDT triggered on this interface";
                              }
    
                              leaf is-label-interface {
                                type boolean;
                                description
                                  "Label Interface flag";
                              }
    
                              leaf is-extranet {
                                type boolean;
                                description
                                  "Extranet flag";
                              }
    
                              leaf turn-around {
                                type boolean;
                                description
                                  "Turnaround flag";
                              }
    
                              leaf amt {
                                type boolean;
                                description
                                  "AMT flag";
                              }
                            }  // container interface-attributes
    
                            leaf type {
                              type uint32;
                              description
                                "Type of Interface";
                            }
    
                            leaf interface {
                              type xr:Interface-name;
                              description
                                "Interface";
                            }
    
                            leaf ul-interface {
                              type xr:Interface-name;
                              description
                                "Underlying Interface";
                            }
    
                            leaf uptime {
                              type uint64;
                              units "second";
                              description
                                "Uptime in seconds";
                            }
    
                            leaf stale-interface {
                              type boolean;
                              description
                                "Interface is stale";
                            }
    
                            leaf amt-port {
                              type uint16;
                              description
                                "AMT Port";
                            }
    
                            leaf nexthop {
                              type inet:ipv4-address;
                              description
                                "Nexthop";
                            }
    
                            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-source {
                              type inet:ipv4-address;
                              description
                                "AMT Source";
                            }
    
                            leaf amt-id {
                              type uint32;
                              description
                                " AMT ID";
                            }
    
                            leaf amt-in-pkts {
                              type uint64;
                              description
                                "Incoming Packtes AMT intterface";
                            }
    
                            leaf amt-in-byets {
                              type uint64;
                              units "byte";
                              description
                                "Incoming Bytes on AMT intterface";
                            }
    
                            leaf amt-out-pkts {
                              type uint64;
                              description
                                "Outgoing Packtes on AMT intterface";
                            }
    
                            leaf amt-out-bytes {
                              type uint64;
                              units "byte";
                              description
                                "Outgoing Bytes on AMT intterface";
                            }
                          }  // list interface
                        }  // list source-group-address
                      }  // container source-group-addresses
    
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
                    }  // list interface-route
                  }  // container interface-routes
    
                  container counters {
                    description
                      "MFWD RouteDB Counters Information";
                    list counters {
                      description
                        "Counters in the main MFIB table";
                      leaf description {
                        type string {
                          length "0..128";
                        }
                        description
                          "Description of the counter";
                      }
    
                      leaf count {
                        type uint32;
                        description
                          "Value of the counter";
                      }
                    }  // list counters
                  }  // container counters
    
                  container interfaces {
                    description
                      "Information about MFWD Interfaces";
                    list interface {
                      key "interface-name";
                      description
                        "MFWD Interface information";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      leaf interface {
                        type xr:Interface-name;
                        description
                          "Interface Handle";
                      }
    
                      leaf is-interface-local {
                        type boolean;
                        description
                          "Is interface local to the node ?";
                      }
    
                      leaf multicast-packets-in {
                        type uint64;
                        description
                          "No. of multicast packets in";
                      }
    
                      leaf multicast-packets-out {
                        type uint64;
                        description
                          "No. of multicast packets out";
                      }
    
                      leaf ttl-threshold {
                        type uint8;
                        description
                          "Multicast TTL threshold";
                      }
    
                      leaf referencecount {
                        type uint32;
                        description
                          "Referencecount of times this interface is
    referenced";
                      }
    
                      leaf is-multicast-interface-enabled {
                        type boolean;
                        description
                          "Is interface multicast enabled";
                      }
                    }  // list interface
                  }  // container interfaces
    
                  container encapsulation-infos {
                    description
                      "Encapsulation InformationTable";
                    list encapsulation-info {
                      key "source source-address group group-address";
                      description
                        "Encapsulation Information";
                      leaf source {
                        type xr:Cisco-ios-xr-string {
                          length "1..9";
                        }
                        description
                          "prev source CTID type";
                      }
    
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "prev source CTID ID 1";
                      }
    
                      leaf group {
                        type xr:Cisco-ios-xr-string {
                          length "1..9";
                        }
                        description
                          "prev group CTID type";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "prev group CTID ID 2";
                      }
    
                      container source-xr {
                        description
                          "Source address";
                        container ctid {
                          description
                            "Core Tree ID";
                          leaf mib-type {
                            type Ipv4-mfwd-show-ctid;
                            description
                              "MIBType";
                          }
    
                          leaf ipv4ctid {
                            when
                              "../mib-type = 'ipv4'" {
                              description
                                "../MIBType = 'IPv4'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 CTID";
                          }
    
                          leaf any-ctid {
                            when
                              "../mib-type = 'any'" {
                              description
                                "../MIBType = 'Any'";
                            }
                            type uint32;
                            description
                              "Any CTID";
                          }
                        }  // container ctid
    
                        leaf mib-type {
                          type Ipv4-mfwd-show-ctid;
                          description
                            "MIB type Deprecated by CTID";
                        }
    
                        leaf id {
                          type uint32;
                          description
                            "ID Deprecated by CTID";
                        }
                      }  // container source-xr
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        container ctid {
                          description
                            "Core Tree ID";
                          leaf mib-type {
                            type Ipv4-mfwd-show-ctid;
                            description
                              "MIBType";
                          }
    
                          leaf ipv4ctid {
                            when
                              "../mib-type = 'ipv4'" {
                              description
                                "../MIBType = 'IPv4'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 CTID";
                          }
    
                          leaf any-ctid {
                            when
                              "../mib-type = 'any'" {
                              description
                                "../MIBType = 'Any'";
                            }
                            type uint32;
                            description
                              "Any CTID";
                          }
                        }  // container ctid
    
                        leaf mib-type {
                          type Ipv4-mfwd-show-ctid;
                          description
                            "MIB type Deprecated by CTID";
                        }
    
                        leaf id {
                          type uint32;
                          description
                            "ID Deprecated by CTID";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf encapsulation-reference-count {
                        type uint32;
                        description
                          "No of VRF routes using this encap ";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf associated-table-id {
                        type uint32;
                        description
                          "Associated Table ID";
                      }
                    }  // list encapsulation-info
                  }  // container encapsulation-infos
    
                  container routes {
                    description
                      "The set of MRIB RouteDB operations";
                    list route {
                      key "source-address group-address prefix-length";
                      description
                        "MFWD Route Entry Information";
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      leaf prefix-length {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "Prefix Length";
                      }
    
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      container entry-attributes {
                        description
                          "Routing entry attributes";
                        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 information";
                        }
    
                        leaf is-inherit-from-set {
                          type boolean;
                          description
                            "Inherit from information";
                        }
    
                        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-unicast-nsf-on {
                          type boolean;
                          description
                            "Unicast NSF flag";
                        }
    
                        leaf is-mdt-encapsulation-on {
                          type boolean;
                          description
                            "MDT Encapsulation flag";
                        }
    
                        leaf is-mdt-decapsulation-on {
                          type boolean;
                          description
                            "MDT Decapsulation flag";
                        }
    
                        leaf is-mdt-address-on {
                          type boolean;
                          description
                            "MDT Address flag";
                        }
    
                        leaf is-threshold-crossed {
                          type boolean;
                          description
                            "Data MDT Threshold Crossed";
                        }
    
                        leaf is-mdt-handle-set {
                          type boolean;
                          description
                            "MDT Handle flag";
                        }
    
                        leaf is-conditional-decapsulation {
                          type boolean;
                          description
                            "Conditional Decapsulation flag";
                        }
    
                        leaf is-packet-decapsulation-true {
                          type boolean;
                          description
                            "Should we decapsulation pkt";
                        }
    
                        leaf is-packet-decapsulation-true-v6 {
                          type boolean;
                          description
                            "decapsulation pkt with v6 payload";
                        }
    
                        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 flag";
                        }
    
                        leaf encapsulation-identifier {
                          type boolean;
                          description
                            "Encap-id present";
                        }
    
                        leaf rpf-identifier {
                          type boolean;
                          description
                            "RPF-id present";
                        }
    
                        leaf mo-frr-enabled {
                          type boolean;
                          description
                            "MoFRR Enable";
                        }
    
                        leaf mo-frr-state {
                          type boolean;
                          description
                            "MOFRR State";
                        }
    
                        leaf mo-frr-primary {
                          type boolean;
                          description
                            "MOFRR Primary";
                        }
    
                        leaf mo-frr-backup {
                          type boolean;
                          description
                            "MOFRR Backup";
                        }
    
                        leaf amt {
                          type boolean;
                          description
                            "AMT State";
                        }
    
                        leaf vx-lan {
                          type boolean;
                          description
                            "VxLAN State";
                        }
                      }  // container entry-attributes
    
                      container parent-group-prefix {
                        description
                          "Inherit from Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container parent-group-prefix
    
                      container lsm-rpf-address {
                        description
                          "LSM RPF Address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container lsm-rpf-address
    
                      container mdt-default-source {
                        description
                          "Source address";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-source
    
                      container mdt-default-group-prefix {
                        description
                          "Group address prefix";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-group-prefix
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf route-version {
                        type uint16;
                        description
                          "Route version";
                      }
    
                      leaf stale-route {
                        type boolean;
                        description
                          "The route is stale";
                      }
    
                      leaf incomplete-route {
                        type boolean;
                        description
                          "The route is incomplete";
                      }
    
                      leaf time-last-used {
                        type string;
                        description
                          "Last time entry was used";
                      }
    
                      leaf bytes-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes out";
                      }
    
                      leaf bytes-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated";
                      }
    
                      leaf packets-in {
                        type uint32;
                        description
                          "No of packets in";
                      }
    
                      leaf packets-out {
                        type uint32;
                        description
                          "No of packets out";
                      }
    
                      leaf packets-rep {
                        type uint32;
                        description
                          "No of packets replicated";
                      }
    
                      leaf packets-failed-rpf {
                        type uint32;
                        description
                          "No of packets which failed rpf";
                      }
    
                      leaf packets-failed-ttl {
                        type uint32;
                        description
                          "No of packets which failed TTL check";
                      }
    
                      leaf outgoing-list-failure-packets {
                        type uint32;
                        description
                          "No of packets dropped due to null olist";
                      }
    
                      leaf encapsulation-ratelimit-drops {
                        type uint32;
                        description
                          "No of encap packets dropped/ratelimited";
                      }
    
                      leaf other-failures {
                        type uint32;
                        description
                          "No of packets dropped due to misc failures";
                      }
    
                      leaf hardware-ingress-packets-in {
                        type uint64;
                        description
                          "No of packets input at ingress metro";
                      }
    
                      leaf hardware-ingress-bytes-in {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes input on this interface";
                      }
    
                      leaf hardware-ingres-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at ingress metro";
                      }
    
                      leaf hardware-egress-packets-out {
                        type uint64;
                        description
                          "No of packets sent out at egress metro";
                      }
    
                      leaf hardware-egress-packets-rep {
                        type uint64;
                        description
                          "No of packets replicated at egress metro";
                      }
    
                      leaf hardware-egress-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at egress metro";
                      }
    
                      leaf hardware-egress-byte-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes sent out at egress metro";
                      }
    
                      leaf hardware-egress-byte-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated at egress metro";
                      }
    
                      leaf is-hardware-ingress-input-counter-valid {
                        type boolean;
                        description
                          "Is input counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-output-counter-valid {
                        type boolean;
                        description
                          "Is output counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-replicate-counter-valid {
                        type boolean;
                        description
                          "Is replicated counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-fwd-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-rep-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes replicated counter at egress metro
    valid ?";
                      }
    
                      leaf parent-group-prefix-length {
                        type uint16;
                        description
                          "Inherit from Group address prefix length";
                      }
    
                      leaf mo-frr-active {
                        type boolean;
                        description
                          "MoFRR Active";
                      }
    
                      leaf mo-frr-sequence-number {
                        type uint32;
                        description
                          "MoFRR Sequence Number";
                      }
    
                      leaf new-mo-frr-active {
                        type boolean;
                        description
                          "New MoFRR Active";
                      }
    
                      leaf new-mo-frr-sequence-number {
                        type uint32;
                        description
                          "New MoFRR Sequence Number";
                      }
    
                      leaf mo-frrhw-event {
                        type boolean;
                        description
                          "Is this an MoFRR Hardware Event";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf is-mdt-encapsulation-info {
                        type boolean;
                        description
                          "MDT Encap information";
                      }
    
                      leaf mdt-default-group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf mdt-associated-table-id {
                        type uint32;
                        description
                          "Associated Table (vrf or Core)";
                      }
    
                      leaf mdt-associated-remote-table-id {
                        type uint32;
                        description
                          "Associated Remote Table (vrf or Core)";
                      }
    
                      leaf is-mdt-data-rate-probe {
                        type boolean;
                        description
                          "Are we probing for rate for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-in-list {
                        type boolean;
                        description
                          "Are we in the list for rate calc for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-throttle {
                        type boolean;
                        description
                          "Is Data MDT rate calculation throttled ?";
                      }
    
                      leaf mdt-data-throttle-left {
                        type uint32;
                        description
                          "Time remaining for throttle to be removed ?";
                      }
    
                      leaf mdt-decapsulation-egress-count {
                        type uint32;
                        description
                          "No. of pkts decapped on SW egress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v4-count {
                        type uint32;
                        description
                          "No. of v4 pkts encapped on SW ingress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v6-count {
                        type uint32;
                        description
                          "No. of v6 pkts encapped on SW ingress node";
                      }
    
                      leaf incoming-traffic-rate {
                        type uint64;
                        description
                          "Incoming traffic rate when MDT is forwarding";
                      }
    
                      leaf is-rate-per-route {
                        type boolean;
                        description
                          "Are we doing rate per route ?";
                      }
    
                      leaf is-prefix-accounting {
                        type boolean;
                        description
                          "Are we doing stats per route ?";
                      }
    
                      leaf annotation {
                        type string;
                        description
                          "Platform annotation";
                      }
    
                      leaf is-hardware-egress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps out rate";
                      }
    
                      leaf is-hardware-ingress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps in rate";
                      }
    
                      leaf is-hardware-egress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps out rate";
                      }
    
                      leaf is-hardware-ingress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps in rate";
                      }
    
                      leaf is-hardware-egress-bytes-rate-counte-valid {
                        type boolean;
                        description
                          "Is egress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-egress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is egress packet per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-bytes-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress packet per sec rate valid?";
                      }
    
                      leaf uptime {
                        type uint64;
                        units "second";
                        description
                          "Uptime in seconds";
                      }
    
                      leaf rpf-table-id {
                        type uint32;
                        description "RPF TID";
                      }
    
                      leaf route-e-gcount {
                        type uint16;
                        description
                          "Route EG count";
                      }
    
                      leaf route-encap-id {
                        type uint32;
                        description "Encap Id";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description "RPF Id";
                      }
    
                      leaf local-receiver {
                        type boolean;
                        description
                          "Local Receiver Flag";
                      }
    
                      leaf turn-around {
                        type boolean;
                        description
                          "Turn Around Flag";
                      }
    
                      leaf next-amt-route {
                        type uint64;
                        description
                          "Next AMT route";
                      }
    
                      leaf prev-amt-route {
                        type uint64;
                        description
                          "Prev AMT route";
                      }
    
                      leaf in-amt-route-list {
                        type boolean;
                        description
                          "Are we in the list of AMT route ?";
                      }
    
                      list interface {
                        description "Interfaces";
                        container interface-attributes {
                          description
                            "Interface attributes";
                          leaf is-forward {
                            type boolean;
                            description
                              "Forwarding flag";
                          }
    
                          leaf is-accept {
                            type boolean;
                            description
                              "Accepting flag";
                          }
    
                          leaf is-accept-backup {
                            type boolean;
                            description
                              "Backup Accepting flag";
                          }
    
                          leaf is-internal-copy {
                            type boolean;
                            description
                              "Internal Copy flag";
                          }
    
                          leaf is-negate-signal {
                            type boolean;
                            description
                              "Negate Signal";
                          }
    
                          leaf is-donot-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-encapsulated-interface {
                            type boolean;
                            description
                              "Encapsulated interface flag";
                          }
    
                          leaf is-egress-interface {
                            type boolean;
                            description
                              "Egress processing flag";
                          }
    
                          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-tr-mdt-interface {
                            type boolean;
                            description
                              "TreeSID MDT Interface flag";
                          }
    
                          leaf is-mdt-data-triggered {
                            type boolean;
                            description
                              "Data MDT triggered on this interface";
                          }
    
                          leaf is-label-interface {
                            type boolean;
                            description
                              "Label Interface flag";
                          }
    
                          leaf is-extranet {
                            type boolean;
                            description
                              "Extranet flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turnaround flag";
                          }
    
                          leaf amt {
                            type boolean;
                            description
                              "AMT flag";
                          }
                        }  // container interface-attributes
    
                        leaf type {
                          type uint32;
                          description
                            "Type of Interface";
                        }
    
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface";
                        }
    
                        leaf ul-interface {
                          type xr:Interface-name;
                          description
                            "Underlying Interface";
                        }
    
                        leaf uptime {
                          type uint64;
                          units "second";
                          description
                            "Uptime in seconds";
                        }
    
                        leaf stale-interface {
                          type boolean;
                          description
                            "Interface is stale";
                        }
    
                        leaf amt-port {
                          type uint16;
                          description "AMT Port";
                        }
    
                        leaf nexthop {
                          type inet:ipv4-address;
                          description "Nexthop";
                        }
    
                        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-source {
                          type inet:ipv4-address;
                          description
                            "AMT Source";
                        }
    
                        leaf amt-id {
                          type uint32;
                          description " AMT ID";
                        }
    
                        leaf amt-in-pkts {
                          type uint64;
                          description
                            "Incoming Packtes AMT intterface";
                        }
    
                        leaf amt-in-byets {
                          type uint64;
                          units "byte";
                          description
                            "Incoming Bytes on AMT intterface";
                        }
    
                        leaf amt-out-pkts {
                          type uint64;
                          description
                            "Outgoing Packtes on AMT intterface";
                        }
    
                        leaf amt-out-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Outgoing Bytes on AMT intterface";
                        }
                      }  // list interface
                    }  // list route
                  }  // container routes
    
                  container svd {
                    description
                      "SVD table information";
                    leaf bcdl-reset-timer {
                      type uint32;
                      description
                        "BCDL reset timer";
                    }
    
                    leaf is-bcd-just-reset {
                      type boolean;
                      description
                        "BCDL connection state";
                    }
    
                    leaf is-platform-svd-state {
                      type boolean;
                      description
                        "Platform SVD state";
                    }
    
                    leaf platform-svd-reason {
                      type uint32;
                      description
                        "Platform SVD update reason";
                    }
    
                    list pending-local-tbl {
                      description
                        "Pending Local table";
                      leaf pending-table-id {
                        type uint32;
                        description "Table ID";
                      }
    
                      leaf pending-table-name {
                        type string;
                        description "Table Name";
                      }
                    }  // list pending-local-tbl
                  }  // container svd
    
                  container connections {
                    description
                      "MFWD RouteDB connections information";
                    leaf-list connection {
                      type boolean;
                      description
                        "Array containing status of each connection";
                    }
                  }  // container connections
    
                  container imdr {
                    description
                      "MFWD RouteDB IMDR status information";
                    leaf imdr-end-of-download-start-received {
                      type boolean;
                      description
                        "IMDR End Of Download Start received state";
                    }
    
                    leaf fib-end-of-download-received {
                      type boolean;
                      description
                        "FIB End Of Download state";
                    }
    
                    leaf im-end-of-download-received {
                      type boolean;
                      description
                        "IM End Of Download state";
                    }
    
                    leaf mfwd-end-of-download-sent {
                      type boolean;
                      description
                        "MFWD End Of Download send state";
                    }
                  }  // container imdr
    
                  container bvi-interfaces {
                    description
                      "MFIB BVI interface mapping";
                    list bvi-interface {
                      key "interface-name";
                      description
                        "BVI Interface Handle";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      leaf vrf-id {
                        type Rsi-vrf-id;
                        description "Vrf Id";
                      }
    
                      leaf vrf-name {
                        type string;
                        description "Vrf Name";
                      }
                    }  // list bvi-interface
                  }  // container bvi-interfaces
    
                  container route-statistics {
                    description
                      "The set of MRIB RouteDB and route statistics
    operations";
                    list route-statistic {
                      key "source-address group-address prefix-length";
                      description
                        "MFWD Route Entry and route statistics
    Information";
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      leaf prefix-length {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "Prefix Length";
                      }
    
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      container entry-attributes {
                        description
                          "Routing entry attributes";
                        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 information";
                        }
    
                        leaf is-inherit-from-set {
                          type boolean;
                          description
                            "Inherit from information";
                        }
    
                        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-unicast-nsf-on {
                          type boolean;
                          description
                            "Unicast NSF flag";
                        }
    
                        leaf is-mdt-encapsulation-on {
                          type boolean;
                          description
                            "MDT Encapsulation flag";
                        }
    
                        leaf is-mdt-decapsulation-on {
                          type boolean;
                          description
                            "MDT Decapsulation flag";
                        }
    
                        leaf is-mdt-address-on {
                          type boolean;
                          description
                            "MDT Address flag";
                        }
    
                        leaf is-threshold-crossed {
                          type boolean;
                          description
                            "Data MDT Threshold Crossed";
                        }
    
                        leaf is-mdt-handle-set {
                          type boolean;
                          description
                            "MDT Handle flag";
                        }
    
                        leaf is-conditional-decapsulation {
                          type boolean;
                          description
                            "Conditional Decapsulation flag";
                        }
    
                        leaf is-packet-decapsulation-true {
                          type boolean;
                          description
                            "Should we decapsulation pkt";
                        }
    
                        leaf is-packet-decapsulation-true-v6 {
                          type boolean;
                          description
                            "decapsulation pkt with v6 payload";
                        }
    
                        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 flag";
                        }
    
                        leaf encapsulation-identifier {
                          type boolean;
                          description
                            "Encap-id present";
                        }
    
                        leaf rpf-identifier {
                          type boolean;
                          description
                            "RPF-id present";
                        }
    
                        leaf mo-frr-enabled {
                          type boolean;
                          description
                            "MoFRR Enable";
                        }
    
                        leaf mo-frr-state {
                          type boolean;
                          description
                            "MOFRR State";
                        }
    
                        leaf mo-frr-primary {
                          type boolean;
                          description
                            "MOFRR Primary";
                        }
    
                        leaf mo-frr-backup {
                          type boolean;
                          description
                            "MOFRR Backup";
                        }
    
                        leaf amt {
                          type boolean;
                          description
                            "AMT State";
                        }
    
                        leaf vx-lan {
                          type boolean;
                          description
                            "VxLAN State";
                        }
                      }  // container entry-attributes
    
                      container parent-group-prefix {
                        description
                          "Inherit from Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container parent-group-prefix
    
                      container lsm-rpf-address {
                        description
                          "LSM RPF Address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container lsm-rpf-address
    
                      container mdt-default-source {
                        description
                          "Source address";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-source
    
                      container mdt-default-group-prefix {
                        description
                          "Group address prefix";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-group-prefix
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf route-version {
                        type uint16;
                        description
                          "Route version";
                      }
    
                      leaf stale-route {
                        type boolean;
                        description
                          "The route is stale";
                      }
    
                      leaf incomplete-route {
                        type boolean;
                        description
                          "The route is incomplete";
                      }
    
                      leaf time-last-used {
                        type string;
                        description
                          "Last time entry was used";
                      }
    
                      leaf bytes-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes out";
                      }
    
                      leaf bytes-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated";
                      }
    
                      leaf packets-in {
                        type uint32;
                        description
                          "No of packets in";
                      }
    
                      leaf packets-out {
                        type uint32;
                        description
                          "No of packets out";
                      }
    
                      leaf packets-rep {
                        type uint32;
                        description
                          "No of packets replicated";
                      }
    
                      leaf packets-failed-rpf {
                        type uint32;
                        description
                          "No of packets which failed rpf";
                      }
    
                      leaf packets-failed-ttl {
                        type uint32;
                        description
                          "No of packets which failed TTL check";
                      }
    
                      leaf outgoing-list-failure-packets {
                        type uint32;
                        description
                          "No of packets dropped due to null olist";
                      }
    
                      leaf encapsulation-ratelimit-drops {
                        type uint32;
                        description
                          "No of encap packets dropped/ratelimited";
                      }
    
                      leaf other-failures {
                        type uint32;
                        description
                          "No of packets dropped due to misc failures";
                      }
    
                      leaf hardware-ingress-packets-in {
                        type uint64;
                        description
                          "No of packets input at ingress metro";
                      }
    
                      leaf hardware-ingress-bytes-in {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes input on this interface";
                      }
    
                      leaf hardware-ingres-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at ingress metro";
                      }
    
                      leaf hardware-egress-packets-out {
                        type uint64;
                        description
                          "No of packets sent out at egress metro";
                      }
    
                      leaf hardware-egress-packets-rep {
                        type uint64;
                        description
                          "No of packets replicated at egress metro";
                      }
    
                      leaf hardware-egress-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at egress metro";
                      }
    
                      leaf hardware-egress-byte-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes sent out at egress metro";
                      }
    
                      leaf hardware-egress-byte-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated at egress metro";
                      }
    
                      leaf is-hardware-ingress-input-counter-valid {
                        type boolean;
                        description
                          "Is input counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-output-counter-valid {
                        type boolean;
                        description
                          "Is output counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-replicate-counter-valid {
                        type boolean;
                        description
                          "Is replicated counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-fwd-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-rep-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes replicated counter at egress metro
    valid ?";
                      }
    
                      leaf parent-group-prefix-length {
                        type uint16;
                        description
                          "Inherit from Group address prefix length";
                      }
    
                      leaf mo-frr-active {
                        type boolean;
                        description
                          "MoFRR Active";
                      }
    
                      leaf mo-frr-sequence-number {
                        type uint32;
                        description
                          "MoFRR Sequence Number";
                      }
    
                      leaf new-mo-frr-active {
                        type boolean;
                        description
                          "New MoFRR Active";
                      }
    
                      leaf new-mo-frr-sequence-number {
                        type uint32;
                        description
                          "New MoFRR Sequence Number";
                      }
    
                      leaf mo-frrhw-event {
                        type boolean;
                        description
                          "Is this an MoFRR Hardware Event";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf is-mdt-encapsulation-info {
                        type boolean;
                        description
                          "MDT Encap information";
                      }
    
                      leaf mdt-default-group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf mdt-associated-table-id {
                        type uint32;
                        description
                          "Associated Table (vrf or Core)";
                      }
    
                      leaf mdt-associated-remote-table-id {
                        type uint32;
                        description
                          "Associated Remote Table (vrf or Core)";
                      }
    
                      leaf is-mdt-data-rate-probe {
                        type boolean;
                        description
                          "Are we probing for rate for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-in-list {
                        type boolean;
                        description
                          "Are we in the list for rate calc for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-throttle {
                        type boolean;
                        description
                          "Is Data MDT rate calculation throttled ?";
                      }
    
                      leaf mdt-data-throttle-left {
                        type uint32;
                        description
                          "Time remaining for throttle to be removed ?";
                      }
    
                      leaf mdt-decapsulation-egress-count {
                        type uint32;
                        description
                          "No. of pkts decapped on SW egress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v4-count {
                        type uint32;
                        description
                          "No. of v4 pkts encapped on SW ingress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v6-count {
                        type uint32;
                        description
                          "No. of v6 pkts encapped on SW ingress node";
                      }
    
                      leaf incoming-traffic-rate {
                        type uint64;
                        description
                          "Incoming traffic rate when MDT is forwarding";
                      }
    
                      leaf is-rate-per-route {
                        type boolean;
                        description
                          "Are we doing rate per route ?";
                      }
    
                      leaf is-prefix-accounting {
                        type boolean;
                        description
                          "Are we doing stats per route ?";
                      }
    
                      leaf annotation {
                        type string;
                        description
                          "Platform annotation";
                      }
    
                      leaf is-hardware-egress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps out rate";
                      }
    
                      leaf is-hardware-ingress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps in rate";
                      }
    
                      leaf is-hardware-egress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps out rate";
                      }
    
                      leaf is-hardware-ingress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps in rate";
                      }
    
                      leaf is-hardware-egress-bytes-rate-counte-valid {
                        type boolean;
                        description
                          "Is egress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-egress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is egress packet per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-bytes-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress packet per sec rate valid?";
                      }
    
                      leaf uptime {
                        type uint64;
                        units "second";
                        description
                          "Uptime in seconds";
                      }
    
                      leaf rpf-table-id {
                        type uint32;
                        description "RPF TID";
                      }
    
                      leaf route-e-gcount {
                        type uint16;
                        description
                          "Route EG count";
                      }
    
                      leaf route-encap-id {
                        type uint32;
                        description "Encap Id";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description "RPF Id";
                      }
    
                      leaf local-receiver {
                        type boolean;
                        description
                          "Local Receiver Flag";
                      }
    
                      leaf turn-around {
                        type boolean;
                        description
                          "Turn Around Flag";
                      }
    
                      leaf next-amt-route {
                        type uint64;
                        description
                          "Next AMT route";
                      }
    
                      leaf prev-amt-route {
                        type uint64;
                        description
                          "Prev AMT route";
                      }
    
                      leaf in-amt-route-list {
                        type boolean;
                        description
                          "Are we in the list of AMT route ?";
                      }
    
                      list interface {
                        description "Interfaces";
                        container interface-attributes {
                          description
                            "Interface attributes";
                          leaf is-forward {
                            type boolean;
                            description
                              "Forwarding flag";
                          }
    
                          leaf is-accept {
                            type boolean;
                            description
                              "Accepting flag";
                          }
    
                          leaf is-accept-backup {
                            type boolean;
                            description
                              "Backup Accepting flag";
                          }
    
                          leaf is-internal-copy {
                            type boolean;
                            description
                              "Internal Copy flag";
                          }
    
                          leaf is-negate-signal {
                            type boolean;
                            description
                              "Negate Signal";
                          }
    
                          leaf is-donot-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-encapsulated-interface {
                            type boolean;
                            description
                              "Encapsulated interface flag";
                          }
    
                          leaf is-egress-interface {
                            type boolean;
                            description
                              "Egress processing flag";
                          }
    
                          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-tr-mdt-interface {
                            type boolean;
                            description
                              "TreeSID MDT Interface flag";
                          }
    
                          leaf is-mdt-data-triggered {
                            type boolean;
                            description
                              "Data MDT triggered on this interface";
                          }
    
                          leaf is-label-interface {
                            type boolean;
                            description
                              "Label Interface flag";
                          }
    
                          leaf is-extranet {
                            type boolean;
                            description
                              "Extranet flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turnaround flag";
                          }
    
                          leaf amt {
                            type boolean;
                            description
                              "AMT flag";
                          }
                        }  // container interface-attributes
    
                        leaf type {
                          type uint32;
                          description
                            "Type of Interface";
                        }
    
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface";
                        }
    
                        leaf ul-interface {
                          type xr:Interface-name;
                          description
                            "Underlying Interface";
                        }
    
                        leaf uptime {
                          type uint64;
                          units "second";
                          description
                            "Uptime in seconds";
                        }
    
                        leaf stale-interface {
                          type boolean;
                          description
                            "Interface is stale";
                        }
    
                        leaf amt-port {
                          type uint16;
                          description "AMT Port";
                        }
    
                        leaf nexthop {
                          type inet:ipv4-address;
                          description "Nexthop";
                        }
    
                        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-source {
                          type inet:ipv4-address;
                          description
                            "AMT Source";
                        }
    
                        leaf amt-id {
                          type uint32;
                          description " AMT ID";
                        }
    
                        leaf amt-in-pkts {
                          type uint64;
                          description
                            "Incoming Packtes AMT intterface";
                        }
    
                        leaf amt-in-byets {
                          type uint64;
                          units "byte";
                          description
                            "Incoming Bytes on AMT intterface";
                        }
    
                        leaf amt-out-pkts {
                          type uint64;
                          description
                            "Outgoing Packtes on AMT intterface";
                        }
    
                        leaf amt-out-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Outgoing Bytes on AMT intterface";
                        }
                      }  // list interface
                    }  // list route-statistic
                  }  // container route-statistics
    
                  leaf database-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..32";
                    }
                    description "Database Name";
                  }
                }  // list database
              }  // container databases
    
              leaf node-name {
                type xr:Node-id;
                description "Node name";
              }
            }  // list node
          }  // container nodes
        }  // container mfwd
    
        container ipv6-mfwd {
          config false;
          description
            "IPV6 MFWD operational data";
          container nodes {
            description "All Nodes";
            list node {
              key "node-name";
              description
                "Multicast Forwarding operational data for this
    particular node";
              container process {
                description "MFWD NSF Databases";
                container nsf {
                  description
                    "MFWD NSF Information";
                  leaf multicast-nsf {
                    type Ipv4-mfwd-nsf-modes;
                    units "second";
                    description
                      "Multicast NSF state in secs";
                  }
    
                  leaf multicast-nsf-time-left {
                    type uint32;
                    units "second";
                    description
                      "Multicast NSF time remaining in secs";
                  }
    
                  leaf ifcnsf {
                    type boolean;
                    description "IFC NSF state";
                  }
                }  // container nsf
    
                container vrfs {
                  description
                    "Traversal in VRF Name/ID DB";
                  list vrf {
                    key "vrf-name";
                    description "VRF";
                    leaf vrf-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description "VRF Name";
                    }
    
                    container mdt-default-source {
                      description
                        "Default MDT Source address";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-source
    
                    container mdt-default-group-prefix {
                      description
                        "Default MDT Group address prefix";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-group-prefix
    
                    leaf rsi-table-name {
                      type string;
                      description
                        "RSI Table Name";
                    }
    
                    leaf rsi-table-id {
                      type uint32;
                      description "RSI Table ID";
                    }
    
                    leaf vrf-id {
                      type uint32;
                      description "RSI VRF ID";
                    }
    
                    leaf vr-id {
                      type uint32;
                      description "RSI VR ID";
                    }
    
                    leaf is-table-active {
                      type boolean;
                      description
                        "Is Table active?";
                    }
    
                    leaf previous-rsi-table-id {
                      type uint32;
                      description
                        "Previous RSI Table ID";
                    }
    
                    leaf is-linked {
                      type boolean;
                      description
                        "Is linked to sibling table?";
                    }
    
                    leaf table-type {
                      type uint8;
                      description "table type";
                    }
    
                    leaf table-location {
                      type Ipv4-mfwd-tbl-location;
                      description
                        "table location";
                    }
    
                    leaf local-interface-count {
                      type uint32;
                      description
                        "Table local intf count";
                    }
    
                    leaf route-count {
                      type uint32;
                      description
                        "Total route count";
                    }
    
                    leaf mdt-default-group-prefix-length {
                      type uint16;
                      description
                        "Default MDT Group address prefix length";
                    }
    
                    leaf mdt-interface {
                      type xr:Interface-name;
                      description
                        "MDT Interface handle";
                    }
    
                    leaf mldp-mdt-interface {
                      type xr:Interface-name;
                      description
                        "MLDP MDT Interface handle";
                    }
    
                    leaf inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "Inband MDT Interface handle";
                    }
    
                    leaf star-g-inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "StarG Inband MDT Interface handle";
                    }
    
                    leaf p2mpte-mdt-interface {
                      type xr:Interface-name;
                      description
                        "P2MPTE MDT Interface handle";
                    }
    
                    leaf ir-mdt-interface {
                      type xr:Interface-name;
                      description
                        "IR MDT Interface handle";
                    }
    
                    leaf tr-mdt-interface {
                      type xr:Interface-name;
                      description
                        "TreeSID MDT Interface handle";
                    }
    
                    leaf mldp-mdt-turnaround {
                      type boolean;
                      description
                        "MLDP MDT Turnaround";
                    }
    
                    leaf p2mpte-mdt-turnaround {
                      type boolean;
                      description
                        "P2MPTE MDT Turnaround";
                    }
    
                    leaf ir-mdt-turnaround {
                      type boolean;
                      description
                        "IR MDT Turnaround";
                    }
    
                    leaf tr-mdt-turnaround {
                      type boolean;
                      description
                        "TreeSID MDT Turnaround";
                    }
    
                    leaf mdt-interface-count {
                      type uint32;
                      description
                        "No of routes using MDT handle";
                    }
    
                    leaf is-mdt-master-linecard {
                      type boolean;
                      description
                        "Is this Master LC table";
                    }
    
                    leaf local-egress-count {
                      type uint32;
                      description
                        "No of local egress interfaces";
                    }
    
                    leaf loopback {
                      type xr:Interface-name;
                      description
                        "Loopback interface handle";
                    }
    
                    leaf customer-mdt-data-acl-name {
                      type string;
                      description
                        "Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-mldpacl-name {
                      type string;
                      description
                        "MLDP Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-p2mpteacl-name {
                      type string;
                      description
                        "P2MPTE Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-iracl-name {
                      type string;
                      description
                        "IR Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-tree-sidacl-name {
                      type string;
                      description
                        "Tree-SID Data MDT ACL Name for customer vrf";
                    }
    
                    leaf is-customer-mdt-data-acl-present {
                      type boolean;
                      description
                        "Is Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-mldpacl-present {
                      type boolean;
                      description
                        "Is MLDP Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-p2mpteacl-present {
                      type boolean;
                      description
                        "Is P2MPTE Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-iracl-present {
                      type boolean;
                      description
                        "Is IR Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-tree-sidacl-present {
                      type boolean;
                      description
                        "Is Tree-SID Data MDT ACL present";
                    }
    
                    leaf data-mdt-threshold {
                      type uint32;
                      description
                        "Data MDT Threshold";
                    }
    
                    leaf is-all-customer-routes-for-data-mdt {
                      type boolean;
                      description
                        "All customer routes for data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-mldp-data-mdt {
                      type boolean;
                      description
                        "All customer routes for MLDP data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-p2mpte-data-mdt {
                      type boolean;
                      description
                        "All customer routes for P2MPTE data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-ir-data-mdt {
                      type boolean;
                      description
                        "All customer routes for IR data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-tree-sid-data-mdt {
                      type boolean;
                      description
                        "All customer routes for Tree-SID data mdt ?";
                    }
    
                    leaf extranet-child-route-count {
                      type uint32;
                      description
                        "Number of child extranet routes";
                    }
                  }  // list vrf
                }  // container vrfs
    
                container table-ids {
                  description
                    "Traversal using Table ID DB";
                  list table-id {
                    key "table-id";
                    description "Table ID";
                    leaf table-id {
                      type uint32;
                      description "Table ID";
                    }
    
                    container mdt-default-source {
                      description
                        "Default MDT Source address";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-source
    
                    container mdt-default-group-prefix {
                      description
                        "Default MDT Group address prefix";
                      leaf id-type {
                        type Ipv4-mfwd-show-ctid;
                        description "IDType";
                      }
    
                      leaf ipv4-mdt-address {
                        when
                          "../id-type = 'ipv4'" {
                          description
                            "../IDType = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description "IPv4 Addr";
                      }
    
                      leaf id {
                        when
                          "../id-type = 'any'" {
                          description
                            "../IDType = 'Any'";
                        }
                        type uint32;
                        description "ID";
                      }
    
                      leaf ipv6-mdt-address {
                        when
                          "../id-type = 'ipv6'" {
                          description
                            "../IDType = 'IPv6'";
                        }
                        type inet:ipv4-address;
                        description "IPv6 Addr";
                      }
                    }  // container mdt-default-group-prefix
    
                    leaf rsi-table-name {
                      type string;
                      description
                        "RSI Table Name";
                    }
    
                    leaf rsi-table-id {
                      type uint32;
                      description "RSI Table ID";
                    }
    
                    leaf vrf-id {
                      type uint32;
                      description "RSI VRF ID";
                    }
    
                    leaf vr-id {
                      type uint32;
                      description "RSI VR ID";
                    }
    
                    leaf is-table-active {
                      type boolean;
                      description
                        "Is Table active?";
                    }
    
                    leaf previous-rsi-table-id {
                      type uint32;
                      description
                        "Previous RSI Table ID";
                    }
    
                    leaf is-linked {
                      type boolean;
                      description
                        "Is linked to sibling table?";
                    }
    
                    leaf table-type {
                      type uint8;
                      description "table type";
                    }
    
                    leaf table-location {
                      type Ipv4-mfwd-tbl-location;
                      description
                        "table location";
                    }
    
                    leaf local-interface-count {
                      type uint32;
                      description
                        "Table local intf count";
                    }
    
                    leaf route-count {
                      type uint32;
                      description
                        "Total route count";
                    }
    
                    leaf mdt-default-group-prefix-length {
                      type uint16;
                      description
                        "Default MDT Group address prefix length";
                    }
    
                    leaf mdt-interface {
                      type xr:Interface-name;
                      description
                        "MDT Interface handle";
                    }
    
                    leaf mldp-mdt-interface {
                      type xr:Interface-name;
                      description
                        "MLDP MDT Interface handle";
                    }
    
                    leaf inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "Inband MDT Interface handle";
                    }
    
                    leaf star-g-inband-mdt-interface {
                      type xr:Interface-name;
                      description
                        "StarG Inband MDT Interface handle";
                    }
    
                    leaf p2mpte-mdt-interface {
                      type xr:Interface-name;
                      description
                        "P2MPTE MDT Interface handle";
                    }
    
                    leaf ir-mdt-interface {
                      type xr:Interface-name;
                      description
                        "IR MDT Interface handle";
                    }
    
                    leaf tr-mdt-interface {
                      type xr:Interface-name;
                      description
                        "TreeSID MDT Interface handle";
                    }
    
                    leaf mldp-mdt-turnaround {
                      type boolean;
                      description
                        "MLDP MDT Turnaround";
                    }
    
                    leaf p2mpte-mdt-turnaround {
                      type boolean;
                      description
                        "P2MPTE MDT Turnaround";
                    }
    
                    leaf ir-mdt-turnaround {
                      type boolean;
                      description
                        "IR MDT Turnaround";
                    }
    
                    leaf tr-mdt-turnaround {
                      type boolean;
                      description
                        "TreeSID MDT Turnaround";
                    }
    
                    leaf mdt-interface-count {
                      type uint32;
                      description
                        "No of routes using MDT handle";
                    }
    
                    leaf is-mdt-master-linecard {
                      type boolean;
                      description
                        "Is this Master LC table";
                    }
    
                    leaf local-egress-count {
                      type uint32;
                      description
                        "No of local egress interfaces";
                    }
    
                    leaf loopback {
                      type xr:Interface-name;
                      description
                        "Loopback interface handle";
                    }
    
                    leaf customer-mdt-data-acl-name {
                      type string;
                      description
                        "Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-mldpacl-name {
                      type string;
                      description
                        "MLDP Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-p2mpteacl-name {
                      type string;
                      description
                        "P2MPTE Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-iracl-name {
                      type string;
                      description
                        "IR Data MDT ACL Name for customer vrf";
                    }
    
                    leaf customer-mdt-data-tree-sidacl-name {
                      type string;
                      description
                        "Tree-SID Data MDT ACL Name for customer vrf";
                    }
    
                    leaf is-customer-mdt-data-acl-present {
                      type boolean;
                      description
                        "Is Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-mldpacl-present {
                      type boolean;
                      description
                        "Is MLDP Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-p2mpteacl-present {
                      type boolean;
                      description
                        "Is P2MPTE Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-iracl-present {
                      type boolean;
                      description
                        "Is IR Data MDT ACL present";
                    }
    
                    leaf is-customer-mdt-data-tree-sidacl-present {
                      type boolean;
                      description
                        "Is Tree-SID Data MDT ACL present";
                    }
    
                    leaf data-mdt-threshold {
                      type uint32;
                      description
                        "Data MDT Threshold";
                    }
    
                    leaf is-all-customer-routes-for-data-mdt {
                      type boolean;
                      description
                        "All customer routes for data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-mldp-data-mdt {
                      type boolean;
                      description
                        "All customer routes for MLDP data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-p2mpte-data-mdt {
                      type boolean;
                      description
                        "All customer routes for P2MPTE data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-ir-data-mdt {
                      type boolean;
                      description
                        "All customer routes for IR data mdt ?";
                    }
    
                    leaf is-all-customer-routes-for-tree-sid-data-mdt {
                      type boolean;
                      description
                        "All customer routes for Tree-SID data mdt ?";
                    }
    
                    leaf extranet-child-route-count {
                      type uint32;
                      description
                        "Number of child extranet routes";
                    }
                  }  // list table-id
                }  // container table-ids
    
                container bvi-routes {
                  description
                    "MFWD BVI route table";
                  list bvi-route {
                    key "interface-name source-address group-address prefix-length";
                    description
                      "MFWD BVI route entry";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Interface Name";
                    }
    
                    leaf source-address {
                      type inet:ip-address-no-zone;
                      description
                        "Source Address";
                    }
    
                    leaf group-address {
                      type inet:ip-address-no-zone;
                      description
                        "Group Address";
                    }
    
                    leaf prefix-length {
                      type uint32;
                      description
                        "Prefix Length";
                    }
    
                    container source {
                      description
                        "Source address";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container source
    
                    container group-prefix {
                      description
                        "Group address prefix";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container group-prefix
    
                    container orig-source {
                      description
                        "Orig Source address";
                      leaf af-name {
                        type Mfwd-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";
                      }
                    }  // container orig-source
    
                    leaf group-prefix-length {
                      type uint8;
                      description
                        "Group address prefix length";
                    }
    
                    leaf bvi-interface {
                      type xr:Interface-name;
                      description
                        "BVI interface";
                    }
    
                    leaf table-name {
                      type string;
                      description "Table Name";
                    }
    
                    leaf uptime {
                      type uint64;
                      description
                        "Time entry has been active";
                    }
    
                    list mroute {
                      description "MRoute";
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      leaf group-prefix-length {
                        type uint8;
                        description
                          "Group address prefix length";
                      }
                    }  // list mroute
                  }  // list bvi-route
                }  // container bvi-routes
              }  // container process
    
              container databases {
                description "MFWD Databases";
                list database {
                  key "database-name";
                  description "Database Name";
                  container encap-registrations {
                    description
                      "MFWD Encap Registration";
                    list encap-registration {
                      key "encap-type lsm-id if-handle source-address group-address";
                      description
                        "MFWD Encap Registration";
                      leaf encap-type {
                        type Encap;
                        description "Encap Type";
                      }
    
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf if-handle {
                        type uint32;
                        description "IFHandle";
                      }
    
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      container registration-type {
                        description "Regdb Type";
                        container reg-dblsm {
                          when
                            "../type = 'lsmid'" {
                            description
                              "../Type = 'lsmid'";
                          }
                          description "LSM Type";
                          leaf lsm-id {
                            type uint32;
                            description
                              "Core LSM ID";
                          }
    
                          leaf reg-is-ecd-stale {
                            type boolean;
                            description
                              "encap reg ECD stale flag";
                          }
    
                          leaf reg-is-ecd-reg {
                            type boolean;
                            description
                              "Encap reg ECD is registered";
                          }
                        }  // container reg-dblsm
    
                        container reg-dbte {
                          when
                            "../type = 'teifh'" {
                            description
                              "../Type = 'teifh'";
                          }
                          description "TE Type";
                          leaf te-ifhandle {
                            type xr:Interface-name;
                            description
                              "Core TE Ifhandle";
                          }
    
                          leaf reg-is-ecd-stale {
                            type boolean;
                            description
                              "Encap reg ECD stale flag";
                          }
    
                          leaf reg-is-ecd-reg {
                            type boolean;
                            description
                              "Encap reg ECD is registered";
                          }
                        }  // container reg-dbte
    
                        container reg-dbgre {
                          when "../type = 'gre'" {
                            description
                              "../Type = 'gre'";
                          }
                          description "GRE Type";
                          container source-address {
                            description
                              "Core Source address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container source-address
    
                          container group-address {
                            description
                              "Core Group address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container group-address
    
                          leaf is-gre-core-valid {
                            type boolean;
                            description
                              "Is GRE Core Valid";
                          }
                        }  // container reg-dbgre
    
                        container reg-dbnh {
                          when "../type = 'nh'" {
                            description
                              "../Type = 'nh'";
                          }
                          description "NH Type";
                          leaf next-hop {
                            type inet:ipv4-address;
                            description
                              "Next hop address";
                          }
                        }  // container reg-dbnh
    
                        container reg-dbtimofrr {
                          when
                            "../type = 'timofrr'" {
                            description
                              "../Type = 'timofrr'";
                          }
                          description
                            "TIMOFRR TYPE";
                          container source-address {
                            description
                              "Core Source address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container source-address
    
                          container group-address {
                            description
                              "Core Group address";
                            container ctid {
                              description
                                "Core Tree ID";
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIBType";
                              }
    
                              leaf ipv4ctid {
                                when
                                  "../mib-type = 'ipv4'" {
                                  description
                                    "../MIBType = 'IPv4'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 CTID";
                              }
    
                              leaf any-ctid {
                                when
                                  "../mib-type = 'any'" {
                                  description
                                    "../MIBType = 'Any'";
                                }
                                type uint32;
                                description
                                  "Any CTID";
                              }
                            }  // container ctid
    
                            leaf mib-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "MIB type Deprecated by CTID";
                            }
    
                            leaf id {
                              type uint32;
                              description
                                "ID Deprecated by CTID";
                            }
                          }  // container group-address
    
                          leaf is-timofrr-core-valid {
                            type boolean;
                            description
                              "Is TI MOFRR Core Valid";
                          }
                        }  // container reg-dbtimofrr
    
                        leaf type {
                          type Ipv4-mfwd-show-encap;
                          description "Type";
                        }
                      }  // container registration-type
    
                      leaf registration-if-handle {
                        type xr:Interface-name;
                        description
                          "Regdb Ifhandle";
                      }
    
                      leaf encap-leaf-count {
                        type uint32;
                        description
                          "Encap Leaf Count";
                      }
                    }  // list encap-registration
                  }  // container encap-registrations
    
                  container summary {
                    description
                      "MFWD RouteDB Summary Information";
                    leaf groutes-count {
                      type uint32;
                      description
                        "No. of (*,G) routes";
                    }
    
                    leaf sg-routes-count {
                      type uint32;
                      description
                        "No. of (S,G) routes";
                    }
    
                    leaf groutes-stale-count {
                      type uint32;
                      description
                        "No. of stale (*,G) routes";
                    }
    
                    leaf sg-routes-stale-count {
                      type uint32;
                      description
                        "No. of stale (S,G) routes";
                    }
    
                    leaf groutes-incomplete-count {
                      type uint32;
                      description
                        "No. of incomplete (*,G) routes";
                    }
    
                    leaf sg-routes-incomplete-count {
                      type uint32;
                      description
                        "No. of incomplete (S,G) routes";
                    }
                  }  // container summary
    
                  container encap-identifiers {
                    description
                      "MFWD Encap Table";
                    list encap-identifier {
                      key "encap-id";
                      description
                        "MFWD Encap Identifier";
                      leaf encap-id {
                        type uint32;
                        description "Encap ID";
                      }
    
                      leaf encap-id-xr {
                        type uint32;
                        description "Encap ID";
                      }
    
                      leaf stale-flag {
                        type boolean;
                        description "Stale flag";
                      }
    
                      leaf encap-lookup-flag {
                        type boolean;
                        description
                          "IP Lookup flag";
                      }
    
                      leaf encap-route-count {
                        type uint32;
                        description
                          "Number of Routes using this Encap";
                      }
    
                      leaf interface-e-gcount {
                        type uint32;
                        description
                          "Number of egress interfaces using this encapid";
                      }
    
                      leaf interface-eg-from-v6 {
                        type boolean;
                        description
                          "Egress interfaces indicated by V6";
                      }
    
                      leaf leaf-count {
                        type uint32;
                        description
                          "Number of Encap OLEs";
                      }
    
                      leaf vr-flite-flag {
                        type boolean;
                        description
                          "MRIB Update VRFLite";
                      }
    
                      leaf v6vr-flite-flag {
                        type boolean;
                        description
                          "MRIB Update v6 VRF lite";
                      }
    
                      list leave {
                        description
                          "Encap Leafs";
                        container type {
                          description
                            "Encap Leaf Type";
                          container encap-gre {
                            when
                              "../type = 'gre'" {
                              description
                                "../Type = 'gre'";
                            }
                            description "GRE";
                            container source-address {
                              description
                                "Core Source address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container source-address
    
                            container group-address {
                              description
                                "Core Group address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container group-address
                          }  // container encap-gre
    
                          container encap-nh {
                            when
                              "../type = 'nh'" {
                              description
                                "../Type = 'nh'";
                            }
                            description "NH";
                            leaf next-hop {
                              type inet:ipv4-address;
                              description
                                "Next hop address";
                            }
                          }  // container encap-nh
    
                          container encap-timofrr {
                            when
                              "../type = 'timofrr'" {
                              description
                                "../Type = 'timofrr'";
                            }
                            description
                              "TIMOFRR";
                            container source-address {
                              description
                                "Core Source address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container source-address
    
                            container group-address {
                              description
                                "Core Group address";
                              container ctid {
                                description
                                  "Core Tree ID";
                                leaf mib-type {
                                  type Ipv4-mfwd-show-ctid;
                                  description
                                    "MIBType";
                                }
    
                                leaf ipv4ctid {
                                  when
                                    "../mib-type = 'ipv4'" {
                                    description
                                      "../MIBType = 'IPv4'";
                                  }
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 CTID";
                                }
    
                                leaf any-ctid {
                                  when
                                    "../mib-type = 'any'" {
                                    description
                                      "../MIBType = 'Any'";
                                  }
                                  type uint32;
                                  description
                                    "Any CTID";
                                }
                              }  // container ctid
    
                              leaf mib-type {
                                type Ipv4-mfwd-show-ctid;
                                description
                                  "MIB type Deprecated by CTID";
                              }
    
                              leaf id {
                                type uint32;
                                description
                                  "ID Deprecated by CTID";
                              }
                            }  // container group-address
                          }  // container encap-timofrr
    
                          leaf type {
                            type Ipv4-mfwd-show-encap;
                            description "Type";
                          }
    
                          leaf lsm-id {
                            when
                              "../type = 'lsmid'" {
                              description
                                "../Type = 'lsmid'";
                            }
                            type uint32;
                            description
                              "Core LSM ID";
                          }
    
                          leaf te-ifhandle {
                            when
                              "../type = 'teifh'" {
                              description
                                "../Type = 'teifh'";
                            }
                            type xr:Interface-name;
                            description
                              "Core TE Ifhandle";
                          }
                        }  // container type
    
                        leaf leaf-tr {
                          type boolean;
                          description
                            "Encap Leaf Turnaround";
                        }
                      }  // list leave
                    }  // list encap-identifier
                  }  // container encap-identifiers
    
                  container detail-interfaces {
                    description
                      "Detailed information about MFWD Interfaces";
                    list detail-interface {
                      key "interface-name";
                      description
                        "Detailed MFWD Interface info";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      container interface-info {
                        description
                          "Basic interface information";
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface Handle";
                        }
    
                        leaf is-interface-local {
                          type boolean;
                          description
                            "Is interface local to the node ?";
                        }
    
                        leaf multicast-packets-in {
                          type uint64;
                          description
                            "No. of multicast packets in";
                        }
    
                        leaf multicast-packets-out {
                          type uint64;
                          description
                            "No. of multicast packets out";
                        }
    
                        leaf ttl-threshold {
                          type uint8;
                          description
                            "Multicast TTL threshold";
                        }
    
                        leaf referencecount {
                          type uint32;
                          description
                            "Referencecount of times this interface is
    referenced";
                        }
    
                        leaf is-multicast-interface-enabled {
                          type boolean;
                          description
                            "Is interface multicast enabled";
                        }
                      }  // container interface-info
    
                      container tunnel-info {
                        description
                          "Tunnel interface information";
                        leaf is-active-tunnel {
                          type boolean;
                          description
                            "Is this interface an active tunnel";
                        }
                      }  // container tunnel-info
    
                      container bundle-info {
                        description
                          "Bundle interface information";
                        leaf bundle-member-count {
                          type uint32;
                          description
                            "No. of bundle members";
                        }
    
                        list member {
                          description
                            "List of currently local and active members of
    the bundle";
                          leaf interface {
                            type xr:Interface-name;
                            description
                              "Interface";
                          }
    
                          leaf ul-identifier {
                            type If-ul-id;
                            description "UL ID";
                          }
                        }  // list member
                      }  // container bundle-info
    
                      leaf interface {
                        type xr:Interface-name;
                        description
                          "Interface Handle";
                      }
    
                      leaf vrf-id {
                        type uint32;
                        description "RSI VRF ID";
                      }
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf route-count {
                        type uint32;
                        description
                          "No of routes associated with this interface";
                      }
    
                      leaf is-explicit-enable {
                        type boolean;
                        description
                          "Is multicast explicitly enabled on the interface";
                      }
    
                      leaf boundary-acl-name {
                        type string;
                        description
                          "Boundary ACL";
                      }
    
                      leaf type {
                        type Ipv4-mfwd-idb-intf;
                        description
                          "Interface type";
                      }
    
                      leaf is-multicast-adjacency-present {
                        type boolean;
                        description
                          "Is adjacency known on this interface ?";
                      }
    
                      leaf create-status {
                        type Ipv4-mfwd-intf-create-state;
                        description
                          "The create status of this interface";
                      }
    
                      leaf bundle-parent {
                        type xr:Interface-name;
                        description
                          "Bundle I/F if this I/F is member of the bundle";
                      }
    
                      leaf underlying-interface {
                        type xr:Interface-name;
                        description
                          "Underlying interface";
                      }
    
                      leaf mdt-mtu {
                        type uint32;
                        description "MDT MTU";
                      }
    
                      leaf remote-mdt-mtu {
                        type uint32;
                        description
                          "Remote MDT MTU";
                      }
    
                      leaf special-referencecount {
                        type uint32;
                        description
                          "Count of Special Updates using this MDT
    interface";
                      }
    
                      leaf mh-referencecount {
                        type uint32;
                        description
                          "Count of Core routes with MH flag & using this
    MDT interface";
                      }
    
                      leaf mi-referencecount {
                        type uint32;
                        description
                          "Count of VRF routes with MI flag MDT interface";
                      }
    
                      leaf is-data-plane-local {
                        type boolean;
                        description
                          "Is the dataplane for this interface local ?";
                      }
    
                      leaf mcast-intf-config-vrf-set {
                        type boolean;
                        description
                          "Multicast Interface configuration VRF present";
                      }
    
                      leaf mcast-intf-config-vrf-error {
                        type boolean;
                        description
                          "Multicast Interface configuration VRF error";
                      }
    
                      leaf mcast-intf-config-vrf-name {
                        type string;
                        description
                          "Multicast Interface configuration VRF Name";
                      }
    
                      leaf in-name-tree {
                        type boolean;
                        description
                          "Is interface present in global name tree";
                      }
    
                      leaf learned-via-gsp {
                        type boolean;
                        description
                          "Is interface learned via gsp";
                      }
    
                      leaf stale-im {
                        type boolean;
                        description
                          "Does interface has stale im info";
                      }
    
                      leaf intf-flag {
                        type uint8;
                        description
                          "Interface flag";
                      }
                    }  // list detail-interface
                  }  // container detail-interfaces
    
                  container interface-routes {
                    description
                      "Display MFIB interface specific information";
                    list interface-route {
                      key "interface-name";
                      description
                        "Interface Table";
                      container source-group-addresses {
                        description
                          "Source,Group Address Table";
                        list source-group-address {
                          key "source-address group-address prefix-length";
                          description
                            "List the routes associated with an
    Interface";
                          leaf source-address {
                            type inet:ip-address-no-zone;
                            description
                              "Source Address";
                          }
    
                          leaf group-address {
                            type inet:ip-address-no-zone;
                            description
                              "Group Address";
                          }
    
                          leaf prefix-length {
                            type uint32 {
                              range "0..128";
                            }
                            description
                              "Prefix Length";
                          }
    
                          container source {
                            description
                              "Source address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container source
    
                          container group-prefix {
                            description
                              "Group address prefix";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container group-prefix
    
                          container orig-source {
                            description
                              "Orig source address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container orig-source
    
                          container entry-attributes {
                            description
                              "Routing entry attributes";
                            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 information";
                            }
    
                            leaf is-inherit-from-set {
                              type boolean;
                              description
                                "Inherit from information";
                            }
    
                            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-unicast-nsf-on {
                              type boolean;
                              description
                                "Unicast NSF flag";
                            }
    
                            leaf is-mdt-encapsulation-on {
                              type boolean;
                              description
                                "MDT Encapsulation flag";
                            }
    
                            leaf is-mdt-decapsulation-on {
                              type boolean;
                              description
                                "MDT Decapsulation flag";
                            }
    
                            leaf is-mdt-address-on {
                              type boolean;
                              description
                                "MDT Address flag";
                            }
    
                            leaf is-threshold-crossed {
                              type boolean;
                              description
                                "Data MDT Threshold Crossed";
                            }
    
                            leaf is-mdt-handle-set {
                              type boolean;
                              description
                                "MDT Handle flag";
                            }
    
                            leaf is-conditional-decapsulation {
                              type boolean;
                              description
                                "Conditional Decapsulation flag";
                            }
    
                            leaf is-packet-decapsulation-true {
                              type boolean;
                              description
                                "Should we decapsulation pkt";
                            }
    
                            leaf is-packet-decapsulation-true-v6 {
                              type boolean;
                              description
                                "decapsulation pkt with v6 payload";
                            }
    
                            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 flag";
                            }
    
                            leaf encapsulation-identifier {
                              type boolean;
                              description
                                "Encap-id present";
                            }
    
                            leaf rpf-identifier {
                              type boolean;
                              description
                                "RPF-id present";
                            }
    
                            leaf mo-frr-enabled {
                              type boolean;
                              description
                                "MoFRR Enable";
                            }
    
                            leaf mo-frr-state {
                              type boolean;
                              description
                                "MOFRR State";
                            }
    
                            leaf mo-frr-primary {
                              type boolean;
                              description
                                "MOFRR Primary";
                            }
    
                            leaf mo-frr-backup {
                              type boolean;
                              description
                                "MOFRR Backup";
                            }
    
                            leaf amt {
                              type boolean;
                              description
                                "AMT State";
                            }
    
                            leaf vx-lan {
                              type boolean;
                              description
                                "VxLAN State";
                            }
                          }  // container entry-attributes
    
                          container parent-group-prefix {
                            description
                              "Inherit from Group address prefix";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container parent-group-prefix
    
                          container lsm-rpf-address {
                            description
                              "LSM RPF Address";
                            leaf af-name {
                              type Mfwd-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";
                            }
                          }  // container lsm-rpf-address
    
                          container mdt-default-source {
                            description
                              "Source address";
                            leaf id-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "IDType";
                            }
    
                            leaf ipv4-mdt-address {
                              when
                                "../id-type = 'ipv4'" {
                                description
                                  "../IDType = 'IPv4'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 Addr";
                            }
    
                            leaf id {
                              when
                                "../id-type = 'any'" {
                                description
                                  "../IDType = 'Any'";
                              }
                              type uint32;
                              description "ID";
                            }
    
                            leaf ipv6-mdt-address {
                              when
                                "../id-type = 'ipv6'" {
                                description
                                  "../IDType = 'IPv6'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv6 Addr";
                            }
                          }  // container mdt-default-source
    
                          container mdt-default-group-prefix {
                            description
                              "Group address prefix";
                            leaf id-type {
                              type Ipv4-mfwd-show-ctid;
                              description
                                "IDType";
                            }
    
                            leaf ipv4-mdt-address {
                              when
                                "../id-type = 'ipv4'" {
                                description
                                  "../IDType = 'IPv4'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 Addr";
                            }
    
                            leaf id {
                              when
                                "../id-type = 'any'" {
                                description
                                  "../IDType = 'Any'";
                              }
                              type uint32;
                              description "ID";
                            }
    
                            leaf ipv6-mdt-address {
                              when
                                "../id-type = 'ipv6'" {
                                description
                                  "../IDType = 'IPv6'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv6 Addr";
                            }
                          }  // container mdt-default-group-prefix
    
                          leaf rsi-table-id {
                            type uint32;
                            description
                              "RSI Table ID";
                          }
    
                          leaf group-prefix-length {
                            type uint16;
                            description
                              "Group address prefix length";
                          }
    
                          leaf route-version {
                            type uint16;
                            description
                              "Route version";
                          }
    
                          leaf stale-route {
                            type boolean;
                            description
                              "The route is stale";
                          }
    
                          leaf incomplete-route {
                            type boolean;
                            description
                              "The route is incomplete";
                          }
    
                          leaf time-last-used {
                            type string;
                            description
                              "Last time entry was used";
                          }
    
                          leaf bytes-out {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes out";
                          }
    
                          leaf bytes-rep {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes replicated";
                          }
    
                          leaf packets-in {
                            type uint32;
                            description
                              "No of packets in";
                          }
    
                          leaf packets-out {
                            type uint32;
                            description
                              "No of packets out";
                          }
    
                          leaf packets-rep {
                            type uint32;
                            description
                              "No of packets replicated";
                          }
    
                          leaf packets-failed-rpf {
                            type uint32;
                            description
                              "No of packets which failed rpf";
                          }
    
                          leaf packets-failed-ttl {
                            type uint32;
                            description
                              "No of packets which failed TTL check";
                          }
    
                          leaf outgoing-list-failure-packets {
                            type uint32;
                            description
                              "No of packets dropped due to null olist";
                          }
    
                          leaf encapsulation-ratelimit-drops {
                            type uint32;
                            description
                              "No of encap packets dropped/ratelimited";
                          }
    
                          leaf other-failures {
                            type uint32;
                            description
                              "No of packets dropped due to misc failures";
                          }
    
                          leaf hardware-ingress-packets-in {
                            type uint64;
                            description
                              "No of packets input at ingress metro";
                          }
    
                          leaf hardware-ingress-bytes-in {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes input on this interface";
                          }
    
                          leaf hardware-ingres-packets-drop {
                            type uint64;
                            description
                              "No of packets dropped at ingress metro";
                          }
    
                          leaf hardware-egress-packets-out {
                            type uint64;
                            description
                              "No of packets sent out at egress metro";
                          }
    
                          leaf hardware-egress-packets-rep {
                            type uint64;
                            description
                              "No of packets replicated at egress metro";
                          }
    
                          leaf hardware-egress-packets-drop {
                            type uint64;
                            description
                              "No of packets dropped at egress metro";
                          }
    
                          leaf hardware-egress-byte-out {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes sent out at egress metro";
                          }
    
                          leaf hardware-egress-byte-rep {
                            type uint64;
                            units "byte";
                            description
                              "No of bytes replicated at egress metro";
                          }
    
                          leaf is-hardware-ingress-input-counter-valid {
                            type boolean;
                            description
                              "Is input counter at ingress metro valid ?";
                          }
    
                          leaf is-hardware-ingress-drop-counter-valid {
                            type boolean;
                            description
                              "Is drop counter at ingress metro valid ?";
                          }
    
                          leaf is-hardware-ingress-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-output-counter-valid {
                            type boolean;
                            description
                              "Is output counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-replicate-counter-valid {
                            type boolean;
                            description
                              "Is replicated counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-drop-counter-valid {
                            type boolean;
                            description
                              "Is drop counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-fwd-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes counter at egress metro valid ?";
                          }
    
                          leaf is-hardware-egress-rep-bytes-counter-valid {
                            type boolean;
                            description
                              "Is bytes replicated counter at egress metro
    valid ?";
                          }
    
                          leaf parent-group-prefix-length {
                            type uint16;
                            description
                              "Inherit from Group address prefix length";
                          }
    
                          leaf mo-frr-active {
                            type boolean;
                            description
                              "MoFRR Active";
                          }
    
                          leaf mo-frr-sequence-number {
                            type uint32;
                            description
                              "MoFRR Sequence Number";
                          }
    
                          leaf new-mo-frr-active {
                            type boolean;
                            description
                              "New MoFRR Active";
                          }
    
                          leaf new-mo-frr-sequence-number {
                            type uint32;
                            description
                              "New MoFRR Sequence Number";
                          }
    
                          leaf mo-frrhw-event {
                            type boolean;
                            description
                              "Is this an MoFRR Hardware Event";
                          }
    
                          leaf mdt-interface {
                            type xr:Interface-name;
                            description
                              "MDT Interface";
                          }
    
                          leaf is-mdt-encapsulation-info {
                            type boolean;
                            description
                              "MDT Encap information";
                          }
    
                          leaf mdt-default-group-prefix-length {
                            type uint16;
                            description
                              "Group address prefix length";
                          }
    
                          leaf mdt-associated-table-id {
                            type uint32;
                            description
                              "Associated Table (vrf or Core)";
                          }
    
                          leaf mdt-associated-remote-table-id {
                            type uint32;
                            description
                              "Associated Remote Table (vrf or Core)";
                          }
    
                          leaf is-mdt-data-rate-probe {
                            type boolean;
                            description
                              "Are we probing for rate for Data MDT ?";
                          }
    
                          leaf is-mdt-data-rate-in-list {
                            type boolean;
                            description
                              "Are we in the list for rate calc for Data MDT ?";
                          }
    
                          leaf is-mdt-data-rate-throttle {
                            type boolean;
                            description
                              "Is Data MDT rate calculation throttled ?";
                          }
    
                          leaf mdt-data-throttle-left {
                            type uint32;
                            description
                              "Time remaining for throttle to be removed ?";
                          }
    
                          leaf mdt-decapsulation-egress-count {
                            type uint32;
                            description
                              "No. of pkts decapped on SW egress node";
                          }
    
                          leaf mdt-encapsulation-ingress-v4-count {
                            type uint32;
                            description
                              "No. of v4 pkts encapped on SW ingress node";
                          }
    
                          leaf mdt-encapsulation-ingress-v6-count {
                            type uint32;
                            description
                              "No. of v6 pkts encapped on SW ingress node";
                          }
    
                          leaf incoming-traffic-rate {
                            type uint64;
                            description
                              "Incoming traffic rate when MDT is forwarding";
                          }
    
                          leaf is-rate-per-route {
                            type boolean;
                            description
                              "Are we doing rate per route ?";
                          }
    
                          leaf is-prefix-accounting {
                            type boolean;
                            description
                              "Are we doing stats per route ?";
                          }
    
                          leaf annotation {
                            type string;
                            description
                              "Platform annotation";
                          }
    
                          leaf is-hardware-egress-bits-per-seconds-average-rate {
                            type uint64;
                            units "bit/s";
                            description
                              "Average bps out rate";
                          }
    
                          leaf is-hardware-ingress-bits-per-seconds-average-rate {
                            type uint64;
                            units "bit/s";
                            description
                              "Average bps in rate";
                          }
    
                          leaf is-hardware-egress-packet-per-seconds-average-rate {
                            type uint64;
                            description
                              "Average pps out rate";
                          }
    
                          leaf is-hardware-ingress-packet-per-seconds-average-rate {
                            type uint64;
                            description
                              "Average pps in rate";
                          }
    
                          leaf is-hardware-egress-bytes-rate-counte-valid {
                            type boolean;
                            description
                              "Is egress bits per sec rate valid?";
                          }
    
                          leaf is-hardware-egress-packets-rate-counter-valid {
                            type boolean;
                            description
                              "Is egress packet per sec rate valid?";
                          }
    
                          leaf is-hardware-ingress-bytes-rate-counter-valid {
                            type boolean;
                            description
                              "Is ingress bits per sec rate valid?";
                          }
    
                          leaf is-hardware-ingress-packets-rate-counter-valid {
                            type boolean;
                            description
                              "Is ingress packet per sec rate valid?";
                          }
    
                          leaf uptime {
                            type uint64;
                            units "second";
                            description
                              "Uptime in seconds";
                          }
    
                          leaf rpf-table-id {
                            type uint32;
                            description
                              "RPF TID";
                          }
    
                          leaf route-e-gcount {
                            type uint16;
                            description
                              "Route EG count";
                          }
    
                          leaf route-encap-id {
                            type uint32;
                            description
                              "Encap Id";
                          }
    
                          leaf rpf-id {
                            type uint32;
                            description "RPF Id";
                          }
    
                          leaf local-receiver {
                            type boolean;
                            description
                              "Local Receiver Flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turn Around Flag";
                          }
    
                          leaf next-amt-route {
                            type uint64;
                            description
                              "Next AMT route";
                          }
    
                          leaf prev-amt-route {
                            type uint64;
                            description
                              "Prev AMT route";
                          }
    
                          leaf in-amt-route-list {
                            type boolean;
                            description
                              "Are we in the list of AMT route ?";
                          }
    
                          list interface {
                            description
                              "Interfaces";
                            container interface-attributes {
                              description
                                "Interface attributes";
                              leaf is-forward {
                                type boolean;
                                description
                                  "Forwarding flag";
                              }
    
                              leaf is-accept {
                                type boolean;
                                description
                                  "Accepting flag";
                              }
    
                              leaf is-accept-backup {
                                type boolean;
                                description
                                  "Backup Accepting flag";
                              }
    
                              leaf is-internal-copy {
                                type boolean;
                                description
                                  "Internal Copy flag";
                              }
    
                              leaf is-negate-signal {
                                type boolean;
                                description
                                  "Negate Signal";
                              }
    
                              leaf is-donot-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-encapsulated-interface {
                                type boolean;
                                description
                                  "Encapsulated interface flag";
                              }
    
                              leaf is-egress-interface {
                                type boolean;
                                description
                                  "Egress processing flag";
                              }
    
                              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-tr-mdt-interface {
                                type boolean;
                                description
                                  "TreeSID MDT Interface flag";
                              }
    
                              leaf is-mdt-data-triggered {
                                type boolean;
                                description
                                  "Data MDT triggered on this interface";
                              }
    
                              leaf is-label-interface {
                                type boolean;
                                description
                                  "Label Interface flag";
                              }
    
                              leaf is-extranet {
                                type boolean;
                                description
                                  "Extranet flag";
                              }
    
                              leaf turn-around {
                                type boolean;
                                description
                                  "Turnaround flag";
                              }
    
                              leaf amt {
                                type boolean;
                                description
                                  "AMT flag";
                              }
                            }  // container interface-attributes
    
                            leaf type {
                              type uint32;
                              description
                                "Type of Interface";
                            }
    
                            leaf interface {
                              type xr:Interface-name;
                              description
                                "Interface";
                            }
    
                            leaf ul-interface {
                              type xr:Interface-name;
                              description
                                "Underlying Interface";
                            }
    
                            leaf uptime {
                              type uint64;
                              units "second";
                              description
                                "Uptime in seconds";
                            }
    
                            leaf stale-interface {
                              type boolean;
                              description
                                "Interface is stale";
                            }
    
                            leaf amt-port {
                              type uint16;
                              description
                                "AMT Port";
                            }
    
                            leaf nexthop {
                              type inet:ipv4-address;
                              description
                                "Nexthop";
                            }
    
                            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-source {
                              type inet:ipv4-address;
                              description
                                "AMT Source";
                            }
    
                            leaf amt-id {
                              type uint32;
                              description
                                " AMT ID";
                            }
    
                            leaf amt-in-pkts {
                              type uint64;
                              description
                                "Incoming Packtes AMT intterface";
                            }
    
                            leaf amt-in-byets {
                              type uint64;
                              units "byte";
                              description
                                "Incoming Bytes on AMT intterface";
                            }
    
                            leaf amt-out-pkts {
                              type uint64;
                              description
                                "Outgoing Packtes on AMT intterface";
                            }
    
                            leaf amt-out-bytes {
                              type uint64;
                              units "byte";
                              description
                                "Outgoing Bytes on AMT intterface";
                            }
                          }  // list interface
                        }  // list source-group-address
                      }  // container source-group-addresses
    
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
                    }  // list interface-route
                  }  // container interface-routes
    
                  container counters {
                    description
                      "MFWD RouteDB Counters Information";
                    list counters {
                      description
                        "Counters in the main MFIB table";
                      leaf description {
                        type string {
                          length "0..128";
                        }
                        description
                          "Description of the counter";
                      }
    
                      leaf count {
                        type uint32;
                        description
                          "Value of the counter";
                      }
                    }  // list counters
                  }  // container counters
    
                  container interfaces {
                    description
                      "Information about MFWD Interfaces";
                    list interface {
                      key "interface-name";
                      description
                        "MFWD Interface information";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      leaf interface {
                        type xr:Interface-name;
                        description
                          "Interface Handle";
                      }
    
                      leaf is-interface-local {
                        type boolean;
                        description
                          "Is interface local to the node ?";
                      }
    
                      leaf multicast-packets-in {
                        type uint64;
                        description
                          "No. of multicast packets in";
                      }
    
                      leaf multicast-packets-out {
                        type uint64;
                        description
                          "No. of multicast packets out";
                      }
    
                      leaf ttl-threshold {
                        type uint8;
                        description
                          "Multicast TTL threshold";
                      }
    
                      leaf referencecount {
                        type uint32;
                        description
                          "Referencecount of times this interface is
    referenced";
                      }
    
                      leaf is-multicast-interface-enabled {
                        type boolean;
                        description
                          "Is interface multicast enabled";
                      }
                    }  // list interface
                  }  // container interfaces
    
                  container encapsulation-infos {
                    description
                      "Encapsulation InformationTable";
                    list encapsulation-info {
                      key "source source-address group group-address";
                      description
                        "Encapsulation Information";
                      leaf source {
                        type xr:Cisco-ios-xr-string {
                          length "1..9";
                        }
                        description
                          "prev source CTID type";
                      }
    
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "prev source CTID ID 1";
                      }
    
                      leaf group {
                        type xr:Cisco-ios-xr-string {
                          length "1..9";
                        }
                        description
                          "prev group CTID type";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "prev group CTID ID 2";
                      }
    
                      container source-xr {
                        description
                          "Source address";
                        container ctid {
                          description
                            "Core Tree ID";
                          leaf mib-type {
                            type Ipv4-mfwd-show-ctid;
                            description
                              "MIBType";
                          }
    
                          leaf ipv4ctid {
                            when
                              "../mib-type = 'ipv4'" {
                              description
                                "../MIBType = 'IPv4'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 CTID";
                          }
    
                          leaf any-ctid {
                            when
                              "../mib-type = 'any'" {
                              description
                                "../MIBType = 'Any'";
                            }
                            type uint32;
                            description
                              "Any CTID";
                          }
                        }  // container ctid
    
                        leaf mib-type {
                          type Ipv4-mfwd-show-ctid;
                          description
                            "MIB type Deprecated by CTID";
                        }
    
                        leaf id {
                          type uint32;
                          description
                            "ID Deprecated by CTID";
                        }
                      }  // container source-xr
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        container ctid {
                          description
                            "Core Tree ID";
                          leaf mib-type {
                            type Ipv4-mfwd-show-ctid;
                            description
                              "MIBType";
                          }
    
                          leaf ipv4ctid {
                            when
                              "../mib-type = 'ipv4'" {
                              description
                                "../MIBType = 'IPv4'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 CTID";
                          }
    
                          leaf any-ctid {
                            when
                              "../mib-type = 'any'" {
                              description
                                "../MIBType = 'Any'";
                            }
                            type uint32;
                            description
                              "Any CTID";
                          }
                        }  // container ctid
    
                        leaf mib-type {
                          type Ipv4-mfwd-show-ctid;
                          description
                            "MIB type Deprecated by CTID";
                        }
    
                        leaf id {
                          type uint32;
                          description
                            "ID Deprecated by CTID";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf encapsulation-reference-count {
                        type uint32;
                        description
                          "No of VRF routes using this encap ";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf associated-table-id {
                        type uint32;
                        description
                          "Associated Table ID";
                      }
                    }  // list encapsulation-info
                  }  // container encapsulation-infos
    
                  container routes {
                    description
                      "The set of MRIB RouteDB operations";
                    list route {
                      key "source-address group-address prefix-length";
                      description
                        "MFWD Route Entry Information";
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      leaf prefix-length {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "Prefix Length";
                      }
    
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      container entry-attributes {
                        description
                          "Routing entry attributes";
                        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 information";
                        }
    
                        leaf is-inherit-from-set {
                          type boolean;
                          description
                            "Inherit from information";
                        }
    
                        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-unicast-nsf-on {
                          type boolean;
                          description
                            "Unicast NSF flag";
                        }
    
                        leaf is-mdt-encapsulation-on {
                          type boolean;
                          description
                            "MDT Encapsulation flag";
                        }
    
                        leaf is-mdt-decapsulation-on {
                          type boolean;
                          description
                            "MDT Decapsulation flag";
                        }
    
                        leaf is-mdt-address-on {
                          type boolean;
                          description
                            "MDT Address flag";
                        }
    
                        leaf is-threshold-crossed {
                          type boolean;
                          description
                            "Data MDT Threshold Crossed";
                        }
    
                        leaf is-mdt-handle-set {
                          type boolean;
                          description
                            "MDT Handle flag";
                        }
    
                        leaf is-conditional-decapsulation {
                          type boolean;
                          description
                            "Conditional Decapsulation flag";
                        }
    
                        leaf is-packet-decapsulation-true {
                          type boolean;
                          description
                            "Should we decapsulation pkt";
                        }
    
                        leaf is-packet-decapsulation-true-v6 {
                          type boolean;
                          description
                            "decapsulation pkt with v6 payload";
                        }
    
                        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 flag";
                        }
    
                        leaf encapsulation-identifier {
                          type boolean;
                          description
                            "Encap-id present";
                        }
    
                        leaf rpf-identifier {
                          type boolean;
                          description
                            "RPF-id present";
                        }
    
                        leaf mo-frr-enabled {
                          type boolean;
                          description
                            "MoFRR Enable";
                        }
    
                        leaf mo-frr-state {
                          type boolean;
                          description
                            "MOFRR State";
                        }
    
                        leaf mo-frr-primary {
                          type boolean;
                          description
                            "MOFRR Primary";
                        }
    
                        leaf mo-frr-backup {
                          type boolean;
                          description
                            "MOFRR Backup";
                        }
    
                        leaf amt {
                          type boolean;
                          description
                            "AMT State";
                        }
    
                        leaf vx-lan {
                          type boolean;
                          description
                            "VxLAN State";
                        }
                      }  // container entry-attributes
    
                      container parent-group-prefix {
                        description
                          "Inherit from Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container parent-group-prefix
    
                      container lsm-rpf-address {
                        description
                          "LSM RPF Address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container lsm-rpf-address
    
                      container mdt-default-source {
                        description
                          "Source address";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-source
    
                      container mdt-default-group-prefix {
                        description
                          "Group address prefix";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-group-prefix
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf route-version {
                        type uint16;
                        description
                          "Route version";
                      }
    
                      leaf stale-route {
                        type boolean;
                        description
                          "The route is stale";
                      }
    
                      leaf incomplete-route {
                        type boolean;
                        description
                          "The route is incomplete";
                      }
    
                      leaf time-last-used {
                        type string;
                        description
                          "Last time entry was used";
                      }
    
                      leaf bytes-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes out";
                      }
    
                      leaf bytes-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated";
                      }
    
                      leaf packets-in {
                        type uint32;
                        description
                          "No of packets in";
                      }
    
                      leaf packets-out {
                        type uint32;
                        description
                          "No of packets out";
                      }
    
                      leaf packets-rep {
                        type uint32;
                        description
                          "No of packets replicated";
                      }
    
                      leaf packets-failed-rpf {
                        type uint32;
                        description
                          "No of packets which failed rpf";
                      }
    
                      leaf packets-failed-ttl {
                        type uint32;
                        description
                          "No of packets which failed TTL check";
                      }
    
                      leaf outgoing-list-failure-packets {
                        type uint32;
                        description
                          "No of packets dropped due to null olist";
                      }
    
                      leaf encapsulation-ratelimit-drops {
                        type uint32;
                        description
                          "No of encap packets dropped/ratelimited";
                      }
    
                      leaf other-failures {
                        type uint32;
                        description
                          "No of packets dropped due to misc failures";
                      }
    
                      leaf hardware-ingress-packets-in {
                        type uint64;
                        description
                          "No of packets input at ingress metro";
                      }
    
                      leaf hardware-ingress-bytes-in {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes input on this interface";
                      }
    
                      leaf hardware-ingres-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at ingress metro";
                      }
    
                      leaf hardware-egress-packets-out {
                        type uint64;
                        description
                          "No of packets sent out at egress metro";
                      }
    
                      leaf hardware-egress-packets-rep {
                        type uint64;
                        description
                          "No of packets replicated at egress metro";
                      }
    
                      leaf hardware-egress-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at egress metro";
                      }
    
                      leaf hardware-egress-byte-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes sent out at egress metro";
                      }
    
                      leaf hardware-egress-byte-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated at egress metro";
                      }
    
                      leaf is-hardware-ingress-input-counter-valid {
                        type boolean;
                        description
                          "Is input counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-output-counter-valid {
                        type boolean;
                        description
                          "Is output counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-replicate-counter-valid {
                        type boolean;
                        description
                          "Is replicated counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-fwd-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-rep-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes replicated counter at egress metro
    valid ?";
                      }
    
                      leaf parent-group-prefix-length {
                        type uint16;
                        description
                          "Inherit from Group address prefix length";
                      }
    
                      leaf mo-frr-active {
                        type boolean;
                        description
                          "MoFRR Active";
                      }
    
                      leaf mo-frr-sequence-number {
                        type uint32;
                        description
                          "MoFRR Sequence Number";
                      }
    
                      leaf new-mo-frr-active {
                        type boolean;
                        description
                          "New MoFRR Active";
                      }
    
                      leaf new-mo-frr-sequence-number {
                        type uint32;
                        description
                          "New MoFRR Sequence Number";
                      }
    
                      leaf mo-frrhw-event {
                        type boolean;
                        description
                          "Is this an MoFRR Hardware Event";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf is-mdt-encapsulation-info {
                        type boolean;
                        description
                          "MDT Encap information";
                      }
    
                      leaf mdt-default-group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf mdt-associated-table-id {
                        type uint32;
                        description
                          "Associated Table (vrf or Core)";
                      }
    
                      leaf mdt-associated-remote-table-id {
                        type uint32;
                        description
                          "Associated Remote Table (vrf or Core)";
                      }
    
                      leaf is-mdt-data-rate-probe {
                        type boolean;
                        description
                          "Are we probing for rate for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-in-list {
                        type boolean;
                        description
                          "Are we in the list for rate calc for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-throttle {
                        type boolean;
                        description
                          "Is Data MDT rate calculation throttled ?";
                      }
    
                      leaf mdt-data-throttle-left {
                        type uint32;
                        description
                          "Time remaining for throttle to be removed ?";
                      }
    
                      leaf mdt-decapsulation-egress-count {
                        type uint32;
                        description
                          "No. of pkts decapped on SW egress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v4-count {
                        type uint32;
                        description
                          "No. of v4 pkts encapped on SW ingress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v6-count {
                        type uint32;
                        description
                          "No. of v6 pkts encapped on SW ingress node";
                      }
    
                      leaf incoming-traffic-rate {
                        type uint64;
                        description
                          "Incoming traffic rate when MDT is forwarding";
                      }
    
                      leaf is-rate-per-route {
                        type boolean;
                        description
                          "Are we doing rate per route ?";
                      }
    
                      leaf is-prefix-accounting {
                        type boolean;
                        description
                          "Are we doing stats per route ?";
                      }
    
                      leaf annotation {
                        type string;
                        description
                          "Platform annotation";
                      }
    
                      leaf is-hardware-egress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps out rate";
                      }
    
                      leaf is-hardware-ingress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps in rate";
                      }
    
                      leaf is-hardware-egress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps out rate";
                      }
    
                      leaf is-hardware-ingress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps in rate";
                      }
    
                      leaf is-hardware-egress-bytes-rate-counte-valid {
                        type boolean;
                        description
                          "Is egress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-egress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is egress packet per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-bytes-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress packet per sec rate valid?";
                      }
    
                      leaf uptime {
                        type uint64;
                        units "second";
                        description
                          "Uptime in seconds";
                      }
    
                      leaf rpf-table-id {
                        type uint32;
                        description "RPF TID";
                      }
    
                      leaf route-e-gcount {
                        type uint16;
                        description
                          "Route EG count";
                      }
    
                      leaf route-encap-id {
                        type uint32;
                        description "Encap Id";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description "RPF Id";
                      }
    
                      leaf local-receiver {
                        type boolean;
                        description
                          "Local Receiver Flag";
                      }
    
                      leaf turn-around {
                        type boolean;
                        description
                          "Turn Around Flag";
                      }
    
                      leaf next-amt-route {
                        type uint64;
                        description
                          "Next AMT route";
                      }
    
                      leaf prev-amt-route {
                        type uint64;
                        description
                          "Prev AMT route";
                      }
    
                      leaf in-amt-route-list {
                        type boolean;
                        description
                          "Are we in the list of AMT route ?";
                      }
    
                      list interface {
                        description "Interfaces";
                        container interface-attributes {
                          description
                            "Interface attributes";
                          leaf is-forward {
                            type boolean;
                            description
                              "Forwarding flag";
                          }
    
                          leaf is-accept {
                            type boolean;
                            description
                              "Accepting flag";
                          }
    
                          leaf is-accept-backup {
                            type boolean;
                            description
                              "Backup Accepting flag";
                          }
    
                          leaf is-internal-copy {
                            type boolean;
                            description
                              "Internal Copy flag";
                          }
    
                          leaf is-negate-signal {
                            type boolean;
                            description
                              "Negate Signal";
                          }
    
                          leaf is-donot-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-encapsulated-interface {
                            type boolean;
                            description
                              "Encapsulated interface flag";
                          }
    
                          leaf is-egress-interface {
                            type boolean;
                            description
                              "Egress processing flag";
                          }
    
                          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-tr-mdt-interface {
                            type boolean;
                            description
                              "TreeSID MDT Interface flag";
                          }
    
                          leaf is-mdt-data-triggered {
                            type boolean;
                            description
                              "Data MDT triggered on this interface";
                          }
    
                          leaf is-label-interface {
                            type boolean;
                            description
                              "Label Interface flag";
                          }
    
                          leaf is-extranet {
                            type boolean;
                            description
                              "Extranet flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turnaround flag";
                          }
    
                          leaf amt {
                            type boolean;
                            description
                              "AMT flag";
                          }
                        }  // container interface-attributes
    
                        leaf type {
                          type uint32;
                          description
                            "Type of Interface";
                        }
    
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface";
                        }
    
                        leaf ul-interface {
                          type xr:Interface-name;
                          description
                            "Underlying Interface";
                        }
    
                        leaf uptime {
                          type uint64;
                          units "second";
                          description
                            "Uptime in seconds";
                        }
    
                        leaf stale-interface {
                          type boolean;
                          description
                            "Interface is stale";
                        }
    
                        leaf amt-port {
                          type uint16;
                          description "AMT Port";
                        }
    
                        leaf nexthop {
                          type inet:ipv4-address;
                          description "Nexthop";
                        }
    
                        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-source {
                          type inet:ipv4-address;
                          description
                            "AMT Source";
                        }
    
                        leaf amt-id {
                          type uint32;
                          description " AMT ID";
                        }
    
                        leaf amt-in-pkts {
                          type uint64;
                          description
                            "Incoming Packtes AMT intterface";
                        }
    
                        leaf amt-in-byets {
                          type uint64;
                          units "byte";
                          description
                            "Incoming Bytes on AMT intterface";
                        }
    
                        leaf amt-out-pkts {
                          type uint64;
                          description
                            "Outgoing Packtes on AMT intterface";
                        }
    
                        leaf amt-out-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Outgoing Bytes on AMT intterface";
                        }
                      }  // list interface
                    }  // list route
                  }  // container routes
    
                  container svd {
                    description
                      "SVD table information";
                    leaf bcdl-reset-timer {
                      type uint32;
                      description
                        "BCDL reset timer";
                    }
    
                    leaf is-bcd-just-reset {
                      type boolean;
                      description
                        "BCDL connection state";
                    }
    
                    leaf is-platform-svd-state {
                      type boolean;
                      description
                        "Platform SVD state";
                    }
    
                    leaf platform-svd-reason {
                      type uint32;
                      description
                        "Platform SVD update reason";
                    }
    
                    list pending-local-tbl {
                      description
                        "Pending Local table";
                      leaf pending-table-id {
                        type uint32;
                        description "Table ID";
                      }
    
                      leaf pending-table-name {
                        type string;
                        description "Table Name";
                      }
                    }  // list pending-local-tbl
                  }  // container svd
    
                  container connections {
                    description
                      "MFWD RouteDB connections information";
                    leaf-list connection {
                      type boolean;
                      description
                        "Array containing status of each connection";
                    }
                  }  // container connections
    
                  container imdr {
                    description
                      "MFWD RouteDB IMDR status information";
                    leaf imdr-end-of-download-start-received {
                      type boolean;
                      description
                        "IMDR End Of Download Start received state";
                    }
    
                    leaf fib-end-of-download-received {
                      type boolean;
                      description
                        "FIB End Of Download state";
                    }
    
                    leaf im-end-of-download-received {
                      type boolean;
                      description
                        "IM End Of Download state";
                    }
    
                    leaf mfwd-end-of-download-sent {
                      type boolean;
                      description
                        "MFWD End Of Download send state";
                    }
                  }  // container imdr
    
                  container bvi-interfaces {
                    description
                      "MFIB BVI interface mapping";
                    list bvi-interface {
                      key "interface-name";
                      description
                        "BVI Interface Handle";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface Name";
                      }
    
                      leaf vrf-id {
                        type Rsi-vrf-id;
                        description "Vrf Id";
                      }
    
                      leaf vrf-name {
                        type string;
                        description "Vrf Name";
                      }
                    }  // list bvi-interface
                  }  // container bvi-interfaces
    
                  container route-statistics {
                    description
                      "The set of MRIB RouteDB and route statistics
    operations";
                    list route-statistic {
                      key "source-address group-address prefix-length";
                      description
                        "MFWD Route Entry and route statistics
    Information";
                      leaf source-address {
                        type inet:ip-address-no-zone;
                        description
                          "Source Address";
                      }
    
                      leaf group-address {
                        type inet:ip-address-no-zone;
                        description
                          "Group Address";
                      }
    
                      leaf prefix-length {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "Prefix Length";
                      }
    
                      container source {
                        description
                          "Source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container source
    
                      container group-prefix {
                        description
                          "Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container group-prefix
    
                      container orig-source {
                        description
                          "Orig source address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container orig-source
    
                      container entry-attributes {
                        description
                          "Routing entry attributes";
                        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 information";
                        }
    
                        leaf is-inherit-from-set {
                          type boolean;
                          description
                            "Inherit from information";
                        }
    
                        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-unicast-nsf-on {
                          type boolean;
                          description
                            "Unicast NSF flag";
                        }
    
                        leaf is-mdt-encapsulation-on {
                          type boolean;
                          description
                            "MDT Encapsulation flag";
                        }
    
                        leaf is-mdt-decapsulation-on {
                          type boolean;
                          description
                            "MDT Decapsulation flag";
                        }
    
                        leaf is-mdt-address-on {
                          type boolean;
                          description
                            "MDT Address flag";
                        }
    
                        leaf is-threshold-crossed {
                          type boolean;
                          description
                            "Data MDT Threshold Crossed";
                        }
    
                        leaf is-mdt-handle-set {
                          type boolean;
                          description
                            "MDT Handle flag";
                        }
    
                        leaf is-conditional-decapsulation {
                          type boolean;
                          description
                            "Conditional Decapsulation flag";
                        }
    
                        leaf is-packet-decapsulation-true {
                          type boolean;
                          description
                            "Should we decapsulation pkt";
                        }
    
                        leaf is-packet-decapsulation-true-v6 {
                          type boolean;
                          description
                            "decapsulation pkt with v6 payload";
                        }
    
                        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 flag";
                        }
    
                        leaf encapsulation-identifier {
                          type boolean;
                          description
                            "Encap-id present";
                        }
    
                        leaf rpf-identifier {
                          type boolean;
                          description
                            "RPF-id present";
                        }
    
                        leaf mo-frr-enabled {
                          type boolean;
                          description
                            "MoFRR Enable";
                        }
    
                        leaf mo-frr-state {
                          type boolean;
                          description
                            "MOFRR State";
                        }
    
                        leaf mo-frr-primary {
                          type boolean;
                          description
                            "MOFRR Primary";
                        }
    
                        leaf mo-frr-backup {
                          type boolean;
                          description
                            "MOFRR Backup";
                        }
    
                        leaf amt {
                          type boolean;
                          description
                            "AMT State";
                        }
    
                        leaf vx-lan {
                          type boolean;
                          description
                            "VxLAN State";
                        }
                      }  // container entry-attributes
    
                      container parent-group-prefix {
                        description
                          "Inherit from Group address prefix";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container parent-group-prefix
    
                      container lsm-rpf-address {
                        description
                          "LSM RPF Address";
                        leaf af-name {
                          type Mfwd-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";
                        }
                      }  // container lsm-rpf-address
    
                      container mdt-default-source {
                        description
                          "Source address";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-source
    
                      container mdt-default-group-prefix {
                        description
                          "Group address prefix";
                        leaf id-type {
                          type Ipv4-mfwd-show-ctid;
                          description "IDType";
                        }
    
                        leaf ipv4-mdt-address {
                          when
                            "../id-type = 'ipv4'" {
                            description
                              "../IDType = 'IPv4'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv4 Addr";
                        }
    
                        leaf id {
                          when
                            "../id-type = 'any'" {
                            description
                              "../IDType = 'Any'";
                          }
                          type uint32;
                          description "ID";
                        }
    
                        leaf ipv6-mdt-address {
                          when
                            "../id-type = 'ipv6'" {
                            description
                              "../IDType = 'IPv6'";
                          }
                          type inet:ipv4-address;
                          description
                            "IPv6 Addr";
                        }
                      }  // container mdt-default-group-prefix
    
                      leaf rsi-table-id {
                        type uint32;
                        description
                          "RSI Table ID";
                      }
    
                      leaf group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf route-version {
                        type uint16;
                        description
                          "Route version";
                      }
    
                      leaf stale-route {
                        type boolean;
                        description
                          "The route is stale";
                      }
    
                      leaf incomplete-route {
                        type boolean;
                        description
                          "The route is incomplete";
                      }
    
                      leaf time-last-used {
                        type string;
                        description
                          "Last time entry was used";
                      }
    
                      leaf bytes-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes out";
                      }
    
                      leaf bytes-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated";
                      }
    
                      leaf packets-in {
                        type uint32;
                        description
                          "No of packets in";
                      }
    
                      leaf packets-out {
                        type uint32;
                        description
                          "No of packets out";
                      }
    
                      leaf packets-rep {
                        type uint32;
                        description
                          "No of packets replicated";
                      }
    
                      leaf packets-failed-rpf {
                        type uint32;
                        description
                          "No of packets which failed rpf";
                      }
    
                      leaf packets-failed-ttl {
                        type uint32;
                        description
                          "No of packets which failed TTL check";
                      }
    
                      leaf outgoing-list-failure-packets {
                        type uint32;
                        description
                          "No of packets dropped due to null olist";
                      }
    
                      leaf encapsulation-ratelimit-drops {
                        type uint32;
                        description
                          "No of encap packets dropped/ratelimited";
                      }
    
                      leaf other-failures {
                        type uint32;
                        description
                          "No of packets dropped due to misc failures";
                      }
    
                      leaf hardware-ingress-packets-in {
                        type uint64;
                        description
                          "No of packets input at ingress metro";
                      }
    
                      leaf hardware-ingress-bytes-in {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes input on this interface";
                      }
    
                      leaf hardware-ingres-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at ingress metro";
                      }
    
                      leaf hardware-egress-packets-out {
                        type uint64;
                        description
                          "No of packets sent out at egress metro";
                      }
    
                      leaf hardware-egress-packets-rep {
                        type uint64;
                        description
                          "No of packets replicated at egress metro";
                      }
    
                      leaf hardware-egress-packets-drop {
                        type uint64;
                        description
                          "No of packets dropped at egress metro";
                      }
    
                      leaf hardware-egress-byte-out {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes sent out at egress metro";
                      }
    
                      leaf hardware-egress-byte-rep {
                        type uint64;
                        units "byte";
                        description
                          "No of bytes replicated at egress metro";
                      }
    
                      leaf is-hardware-ingress-input-counter-valid {
                        type boolean;
                        description
                          "Is input counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at ingress metro valid ?";
                      }
    
                      leaf is-hardware-ingress-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-output-counter-valid {
                        type boolean;
                        description
                          "Is output counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-replicate-counter-valid {
                        type boolean;
                        description
                          "Is replicated counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-drop-counter-valid {
                        type boolean;
                        description
                          "Is drop counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-fwd-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes counter at egress metro valid ?";
                      }
    
                      leaf is-hardware-egress-rep-bytes-counter-valid {
                        type boolean;
                        description
                          "Is bytes replicated counter at egress metro
    valid ?";
                      }
    
                      leaf parent-group-prefix-length {
                        type uint16;
                        description
                          "Inherit from Group address prefix length";
                      }
    
                      leaf mo-frr-active {
                        type boolean;
                        description
                          "MoFRR Active";
                      }
    
                      leaf mo-frr-sequence-number {
                        type uint32;
                        description
                          "MoFRR Sequence Number";
                      }
    
                      leaf new-mo-frr-active {
                        type boolean;
                        description
                          "New MoFRR Active";
                      }
    
                      leaf new-mo-frr-sequence-number {
                        type uint32;
                        description
                          "New MoFRR Sequence Number";
                      }
    
                      leaf mo-frrhw-event {
                        type boolean;
                        description
                          "Is this an MoFRR Hardware Event";
                      }
    
                      leaf mdt-interface {
                        type xr:Interface-name;
                        description
                          "MDT Interface";
                      }
    
                      leaf is-mdt-encapsulation-info {
                        type boolean;
                        description
                          "MDT Encap information";
                      }
    
                      leaf mdt-default-group-prefix-length {
                        type uint16;
                        description
                          "Group address prefix length";
                      }
    
                      leaf mdt-associated-table-id {
                        type uint32;
                        description
                          "Associated Table (vrf or Core)";
                      }
    
                      leaf mdt-associated-remote-table-id {
                        type uint32;
                        description
                          "Associated Remote Table (vrf or Core)";
                      }
    
                      leaf is-mdt-data-rate-probe {
                        type boolean;
                        description
                          "Are we probing for rate for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-in-list {
                        type boolean;
                        description
                          "Are we in the list for rate calc for Data MDT ?";
                      }
    
                      leaf is-mdt-data-rate-throttle {
                        type boolean;
                        description
                          "Is Data MDT rate calculation throttled ?";
                      }
    
                      leaf mdt-data-throttle-left {
                        type uint32;
                        description
                          "Time remaining for throttle to be removed ?";
                      }
    
                      leaf mdt-decapsulation-egress-count {
                        type uint32;
                        description
                          "No. of pkts decapped on SW egress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v4-count {
                        type uint32;
                        description
                          "No. of v4 pkts encapped on SW ingress node";
                      }
    
                      leaf mdt-encapsulation-ingress-v6-count {
                        type uint32;
                        description
                          "No. of v6 pkts encapped on SW ingress node";
                      }
    
                      leaf incoming-traffic-rate {
                        type uint64;
                        description
                          "Incoming traffic rate when MDT is forwarding";
                      }
    
                      leaf is-rate-per-route {
                        type boolean;
                        description
                          "Are we doing rate per route ?";
                      }
    
                      leaf is-prefix-accounting {
                        type boolean;
                        description
                          "Are we doing stats per route ?";
                      }
    
                      leaf annotation {
                        type string;
                        description
                          "Platform annotation";
                      }
    
                      leaf is-hardware-egress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps out rate";
                      }
    
                      leaf is-hardware-ingress-bits-per-seconds-average-rate {
                        type uint64;
                        units "bit/s";
                        description
                          "Average bps in rate";
                      }
    
                      leaf is-hardware-egress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps out rate";
                      }
    
                      leaf is-hardware-ingress-packet-per-seconds-average-rate {
                        type uint64;
                        description
                          "Average pps in rate";
                      }
    
                      leaf is-hardware-egress-bytes-rate-counte-valid {
                        type boolean;
                        description
                          "Is egress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-egress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is egress packet per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-bytes-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress bits per sec rate valid?";
                      }
    
                      leaf is-hardware-ingress-packets-rate-counter-valid {
                        type boolean;
                        description
                          "Is ingress packet per sec rate valid?";
                      }
    
                      leaf uptime {
                        type uint64;
                        units "second";
                        description
                          "Uptime in seconds";
                      }
    
                      leaf rpf-table-id {
                        type uint32;
                        description "RPF TID";
                      }
    
                      leaf route-e-gcount {
                        type uint16;
                        description
                          "Route EG count";
                      }
    
                      leaf route-encap-id {
                        type uint32;
                        description "Encap Id";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description "RPF Id";
                      }
    
                      leaf local-receiver {
                        type boolean;
                        description
                          "Local Receiver Flag";
                      }
    
                      leaf turn-around {
                        type boolean;
                        description
                          "Turn Around Flag";
                      }
    
                      leaf next-amt-route {
                        type uint64;
                        description
                          "Next AMT route";
                      }
    
                      leaf prev-amt-route {
                        type uint64;
                        description
                          "Prev AMT route";
                      }
    
                      leaf in-amt-route-list {
                        type boolean;
                        description
                          "Are we in the list of AMT route ?";
                      }
    
                      list interface {
                        description "Interfaces";
                        container interface-attributes {
                          description
                            "Interface attributes";
                          leaf is-forward {
                            type boolean;
                            description
                              "Forwarding flag";
                          }
    
                          leaf is-accept {
                            type boolean;
                            description
                              "Accepting flag";
                          }
    
                          leaf is-accept-backup {
                            type boolean;
                            description
                              "Backup Accepting flag";
                          }
    
                          leaf is-internal-copy {
                            type boolean;
                            description
                              "Internal Copy flag";
                          }
    
                          leaf is-negate-signal {
                            type boolean;
                            description
                              "Negate Signal";
                          }
    
                          leaf is-donot-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-encapsulated-interface {
                            type boolean;
                            description
                              "Encapsulated interface flag";
                          }
    
                          leaf is-egress-interface {
                            type boolean;
                            description
                              "Egress processing flag";
                          }
    
                          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-tr-mdt-interface {
                            type boolean;
                            description
                              "TreeSID MDT Interface flag";
                          }
    
                          leaf is-mdt-data-triggered {
                            type boolean;
                            description
                              "Data MDT triggered on this interface";
                          }
    
                          leaf is-label-interface {
                            type boolean;
                            description
                              "Label Interface flag";
                          }
    
                          leaf is-extranet {
                            type boolean;
                            description
                              "Extranet flag";
                          }
    
                          leaf turn-around {
                            type boolean;
                            description
                              "Turnaround flag";
                          }
    
                          leaf amt {
                            type boolean;
                            description
                              "AMT flag";
                          }
                        }  // container interface-attributes
    
                        leaf type {
                          type uint32;
                          description
                            "Type of Interface";
                        }
    
                        leaf interface {
                          type xr:Interface-name;
                          description
                            "Interface";
                        }
    
                        leaf ul-interface {
                          type xr:Interface-name;
                          description
                            "Underlying Interface";
                        }
    
                        leaf uptime {
                          type uint64;
                          units "second";
                          description
                            "Uptime in seconds";
                        }
    
                        leaf stale-interface {
                          type boolean;
                          description
                            "Interface is stale";
                        }
    
                        leaf amt-port {
                          type uint16;
                          description "AMT Port";
                        }
    
                        leaf nexthop {
                          type inet:ipv4-address;
                          description "Nexthop";
                        }
    
                        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-source {
                          type inet:ipv4-address;
                          description
                            "AMT Source";
                        }
    
                        leaf amt-id {
                          type uint32;
                          description " AMT ID";
                        }
    
                        leaf amt-in-pkts {
                          type uint64;
                          description
                            "Incoming Packtes AMT intterface";
                        }
    
                        leaf amt-in-byets {
                          type uint64;
                          units "byte";
                          description
                            "Incoming Bytes on AMT intterface";
                        }
    
                        leaf amt-out-pkts {
                          type uint64;
                          description
                            "Outgoing Packtes on AMT intterface";
                        }
    
                        leaf amt-out-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Outgoing Bytes on AMT intterface";
                        }
                      }  // list interface
                    }  // list route-statistic
                  }  // container route-statistics
    
                  leaf database-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..32";
                    }
                    description "Database Name";
                  }
                }  // list database
              }  // container databases
    
              leaf node-name {
                type xr:Node-id;
                description "Node name";
              }
            }  // list node
          }  // container nodes
        }  // container ipv6-mfwd
      }  // module Cisco-IOS-XR-mfwd-oper
    

© 2023 YumaWorks, Inc. All rights reserved.