Cisco-IOS-XR-ip-rib-ipv4-oper

This module contains a collection of YANG definitions for Cisco IOS-XR ip-rib-ipv4 package operational data. This module contai...

  • Version: 2020-12-11

    Cisco-IOS-XR-ip-rib-ipv4-oper@2020-12-11


    
      module Cisco-IOS-XR-ip-rib-ipv4-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rib-ipv4-oper";
    
        prefix ip-rib-ipv4-oper;
    
        import ietf-inet-types {
          prefix inet;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-ip-rib-ipv4-oper-sub1 {
          revision-date "2020-12-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 ip-rib-ipv4 package operational data.
         
         This module contains definitions
         for the following management objects:
           rib-stdby: RIB standby node operational data
           rib: RIB operational data
         
         Copyright (c) 2013-2020 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2020-12-11" {
          description
            "Add forwarding sidlist
           2020-10-16
             Route model now includes optional SRv6 SID Format field for SRv6 Local SID routes
           2020-09-30
             Nexthop notification model now includes client specific registration flags";
        }
    
        revision "2020-05-29" {
          description
            "Updated the max number of elements for opaque stats to 16 Extended rib edm path to include IID info and SID Format type
           2020-04-02
           Increased path_num size in redist hist route bag to 16 bits";
        }
    
        revision "2019-11-05" {
          description
            "Extended Nexthop and NexhopPrefix paths to include all by NH flags
           2019-10-22
           Extended rib_edm_client_stats_summary to include client stats on bcdl ugs Extended rib_edm_local_label to support AIB prefer Extended rib_edm_path to include recursion length field Extended rib_edm_path to include metric field Extended iidmgr_summary to include oor summary info Extended rib_edm_route to include l3 route type field";
        }
    
        revision "2019-06-28" {
          description "Fixed NexthopPrefix path";
        }
    
        revision "2019-06-08" {
          description "Added RPF list and NHIDs";
        }
    
        revision "2019-05-30" {
          description
            "Fixed adverts and backup paths";
        }
    
        revision "2019-05-17" {
          description
            "Added Nexthops Summary, Nexthop Route, Longer Routes, Redist Clients and Client Stasts";
        }
    
        revision "2019-04-25" {
          description
            "Updated yang schema to extend Native Yang model for the data exposed via CLI";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2019-02-21" {
          description
            "Yang evaluator: updates to schema descriptions and ranges";
        }
    
        revision "2019-01-11" {
          description
            "Route lookup key is limited to Prefix and Prefix Length";
        }
    
        revision "2018-11-20" {
          description
            "Add keys for route lookup via restconf.";
        }
    
        revision "2018-11-06" {
          description
            "Support Algorithm Label List per route";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "4.0.0";
        semver:module-version "3.0.0";
        semver:module-version "2.0.0";
        semver:module-version "1.0.0";
    
        typedef Rpf-head-count-range {
          type uint32 {
            range "0..4294967295";
          }
          description "Rpf head count range";
        }
    
        typedef Rib-saf-name {
          type string {
            pattern "(Unicast)|(Multicast)";
          }
          description
            "Unicast:   Comment: Ucast string for <safi_name>,
           Multicast: Comment: Mcast string for <safi_name>";
        }
    
        typedef Rib-af-name {
          type string {
            pattern "(IPv4)|(IPv6)";
          }
          description
            "IPv4: Comment: v4 string for <afi_name>, IPv6:
           Comment: v6 string for <afi_name>";
        }
    
        typedef Table-id-range-ipv4 {
          type uint32 {
            range "0..4294967295";
          }
          description "Table id range ipv4";
        }
    
        typedef Nhid-hist-count-range {
          type uint32 {
            range "0..4294967295";
          }
          description "Nhid hist count range";
        }
    
        typedef Nhid-entry-count-range {
          type uint32 {
            range "0..4294967295";
          }
          description "Nhid entry count range";
        }
    
        container rib-stdby {
          config false;
          description
            "RIB standby node operational data";
          container rib-nh-id-histories {
            description "nhids history";
            list rib-nh-id-history {
              key "nh-idi-hist-count";
              description "NH Id history count";
              leaf nh-idi-hist-count {
                type Nhid-hist-count-range;
                description "NH Id hist count";
              }
    
              leaf nhid {
                type uint32;
                description "nhid";
              }
    
              leaf nh-addr {
                type Ipv4-rib-edm-addr;
                description "nh addr";
              }
    
              leaf ifindex {
                type xr:Interface-name;
                description "ifindex";
              }
    
              leaf tableid {
                type uint32;
                description "tableid";
              }
    
              leaf operation {
                type uint32;
                description "operation";
              }
    
              leaf update {
                type uint32;
                description "update";
              }
    
              leaf oper-time {
                type uint64;
                description "oper time";
              }
    
              leaf feature-type {
                type uint8;
                description "feature type";
              }
    
              leaf chkpt-obj-id {
                type uint32;
                description "chkpt obj id";
              }
            }  // list rib-nh-id-history
          }  // container rib-nh-id-histories
    
          container rib-update-groups {
            description "RIB UpdateGroup table";
            list rib-update-group {
              key "update-group-id";
              description "UpdateGroup id";
              container rib-update-group-info {
                description
                  "Information of specific updategroup";
                leaf ug-id {
                  type uint32;
                  description "Update Group ID";
                }
    
                leaf client-id {
                  type uint32;
                  description
                    "ClientId associated with UG";
                }
    
                leaf parent-id {
                  type int32;
                  description
                    "UG's parent if child";
                }
    
                leaf insync {
                  type boolean;
                  description
                    "Is this ug insync with RIB";
                }
    
                leaf freezecnt {
                  type uint32;
                  description
                    "Freeze count if frozen";
                }
              }  // container rib-update-group-info
    
              leaf update-group-id {
                type uint32;
                description "UpdateGroup Id";
              }
            }  // list rib-update-group
          }  // container rib-update-groups
    
          container rib-update-group-pruned-nodes {
            description
              "Information of updategroup pruned nodes";
            container rib-update-group-pruned-nodes-info {
              description
                "Information of updategroup pruned nodes";
              leaf num-pruned-nodes {
                type uint32;
                description
                  "Number of pruned nodes";
              }
    
              list pruned-node {
                max-elements 256;
                description "Pruned nodes ID";
                leaf entry {
                  type uint32;
                  description "Pruned nodes ID";
                }
              }  // list pruned-node
            }  // container rib-update-group-pruned-nodes-info
          }  // container rib-update-group-pruned-nodes
    
          container vrfs {
            description "VRF table";
            list vrf {
              key "vrf-name";
              description "Specific VRF";
              container afs {
                description
                  "Address Family (AF) table";
                list af {
                  key "af-name";
                  description
                    "Specific AF information";
                  container safs {
                    description
                      "Subsequent Address Family (SAF) table";
                    list saf {
                      key "saf-name";
                      description
                        "Specific SAF information";
                      container ip-rib-route-table-names {
                        description
                          "Global container of routes";
                        list ip-rib-route-table-name {
                          key "route-table-name";
                          description
                            "IP RIB Route table name for a topology";
                          container routes {
                            description
                              "Route information ";
                            list route {
                              key "address prefix-length";
                              description
                                "Route information of a specific Network
    Address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Network Address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the network address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list route
                          }  // container routes
    
                          container deleted-routes {
                            description
                              "Deleted";
                            list deleted-route {
                              key "address prefix-length";
                              description
                                "Route information for a specific
    deleted address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Deleted network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the deleted network
    address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list deleted-route
                          }  // container deleted-routes
    
                          container destination-kw {
                            description
                              "Destination KW";
                            container dest-best-routes {
                              description
                                "Best Local";
                              list dest-best-route {
                                key "address";
                                description
                                  "Best local route information for a
    specific Address ";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-best-route
                            }  // container dest-best-routes
    
                            container dest-q-routes {
                              description
                                "Quarantine";
                              list dest-q-route {
                                key "address prefix-length";
                                description
                                  "Route information of a specific
    quarantined address ";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Quarantined network address";
                                }
    
                                leaf prefix-length {
                                  type xr:Ipv4-prefix-length;
                                  description
                                    "prefix length of the quarantined
    network address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-q-route
                            }  // container dest-q-routes
    
                            container dest-backup-kw {
                              description
                                "Backup";
                              container dest-backup-prefixes {
                                description
                                  "Backup adresses prefix table";
                                list dest-backup-prefix {
                                  key "address prefix-length";
                                  description
                                    "Route information of a specific
    Backup Address ";
                                  container dest-backup-routes {
                                    description
                                      "Backup adresses route table";
                                    list dest-backup-route {
                                      key "protoid";
                                      description
                                        "Route information of a specific
    Backup Address and Client ";
                                      leaf protoid {
                                        type uint32 {
                                          range
                                            "0..96";
                                        }
                                        description
                                          "Proto ID";
                                      }
    
                                      container srv6-info {
                                        description
                                          "SRv6 related information";
                                        container srv6-endpoint-behavior {
                                          description
                                            "SRv6 Endpoint behavior/type";
                                          leaf type {
                                            type Mgmt-srv6-endpoint;
                                            description
                                              "Behavior type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Behavior description";
                                          }
                                        }  // container srv6-endpoint-behavior
    
                                        container srv6-format {
                                          description
                                            "SRv6 Format";
                                          leaf type {
                                            type Mgmt-srv6-sid-fmt;
                                            description
                                              "Format type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Format description";
                                          }
                                        }  // container srv6-format
    
                                        leaf is-srv6-endpoint {
                                          type boolean;
                                          description
                                            "Route is an SRv6 Endpoint (local SID)";
                                        }
    
                                        leaf is-srv6-locator {
                                          type boolean;
                                          description
                                            "Route corresponds to an SRv6 remote locator";
                                        }
    
                                        leaf srv6-locator-algo {
                                          type uint8;
                                          description
                                            "SRv6 Algo corresponding to SRv6 remote locator";
                                        }
                                      }  // container srv6-info
    
                                      container route-path {
                                        description
                                          "Path(s) of the route";
                                        list ipv4-rib-edm-path {
                                          description
                                            "Next path";
                                          container l2-info {
                                            description
                                              "L2 Info for this path";
                                            leaf xcid {
                                              type uint32;
                                              description
                                                "L2 Cross Connect ID for this path";
                                            }
    
                                            leaf ac-interface {
                                              type xr:Interface-name;
                                              description
                                                "L2 AC Interface";
                                            }
                                          }  // container l2-info
    
                                          container srv6-info {
                                            description
                                              "SRv6 related information";
                                            container srv6-carrier-format {
                                              description
                                                "SRv6 Carrier Format";
                                              leaf type {
                                                type Mgmt-srv6-sid-fmt;
                                                description
                                                  "Format type";
                                              }
    
                                              leaf description {
                                                type string;
                                                description
                                                  "Format description";
                                              }
                                            }  // container srv6-carrier-format
    
                                            container srv6-headend-behavior {
                                              description
                                                "SRv6 headend behavior/type info";
                                              leaf type {
                                                type Mgmt-srv6-headend;
                                                description
                                                  "Behavior type";
                                              }
    
                                              leaf description {
                                                type string;
                                                description
                                                  "Behavior description";
                                              }
                                            }  // container srv6-headend-behavior
    
                                            container via-srv6-sid {
                                              description
                                                "Via-SRv6-SID value";
                                              leaf sid {
                                                type inet:ipv6-address;
                                                description
                                                  "Via-SRv6-SID value";
                                              }
    
                                              leaf resolution-length {
                                                type uint8;
                                                description
                                                  "FIB Resolution length";
                                              }
                                            }  // container via-srv6-sid
    
                                            leaf number-of-srv6-carriers {
                                              type uint8;
                                              description
                                                "Number of SRv6 Carriers";
                                            }
    
                                            leaf has-srv6-headend-behavior {
                                              type boolean;
                                              description
                                                "Path has some SRv6 head-end behavior associated";
                                            }
    
                                            leaf has-via-srv6-sid {
                                              type boolean;
                                              description
                                                "Via-SRv6-SID is present";
                                            }
    
                                            list srv6-carrier {
                                              description
                                                "List of SRv6 Carriers with one or more SIDs";
                                              leaf sid {
                                                type inet:ipv6-address;
                                                description
                                                  "SID value";
                                              }
                                            }  // list srv6-carrier
                                          }  // container srv6-info
    
                                          leaf address {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Nexthop";
                                          }
    
                                          leaf information-source {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Infosource";
                                          }
    
                                          leaf v6-nexthop {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type inet:ipv6-address;
                                            description
                                              "IPv6 nexthop for v4 over v6";
                                          }
    
                                          leaf v6-information-source {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type inet:ipv6-address;
                                            description
                                              "V6 Infosource";
                                          }
    
                                          leaf interface-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type xr:Interface-name;
                                            description
                                              "Interface handle for the path's nexthop";
                                          }
    
                                          leaf metric {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Metrics";
                                          }
    
                                          leaf load-metric {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Load Metrics";
                                          }
    
                                          leaf flags64 {
                                            type uint64;
                                            description
                                              "Flags extended to 64 bits";
                                          }
    
                                          leaf flags {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint16;
                                            description
                                              "Flags";
                                          }
    
                                          leaf private-flags {
                                            type uint16;
                                            description
                                              "Private Flags, used internally by RIB";
                                          }
    
                                          leaf minimum-recurse-length {
                                            type uint8;
                                            description
                                              "Minimum netmask length of recursive resolving
    route";
                                          }
    
                                          leaf looped {
                                            type boolean;
                                            description
                                              "Looping path";
                                          }
    
                                          leaf next-hop-table-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "The table to which the next hop belongs";
                                          }
    
                                          leaf next-hop-vrf-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "VRF Name of the nh table";
                                          }
    
                                          leaf next-hop-table-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "NH table name";
                                          }
    
                                          leaf next-hop-afi {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NH afi";
                                          }
    
                                          leaf next-hop-safi {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NH safi";
                                          }
    
                                          leaf route-label {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Label associated with this path";
                                          }
    
                                          leaf tunnel-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Tunnel ID associated with this path";
                                          }
    
                                          leaf pathid {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Path id of this path";
                                          }
    
                                          leaf backup-pathid {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Path id of this path's backup";
                                          }
    
                                          leaf ref-cnt-of-backup {
                                            type uint32;
                                            description
                                              "For backup paths, the number of active paths
    protected by the backup path";
                                          }
    
                                          leaf number-of-extended-communities {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Number of extended communities associated with
    this path";
                                          }
    
                                          leaf mvpn-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "MVPN attribute present";
                                          }
    
                                          leaf path-rt-present {
                                            type boolean;
                                            description
                                              "Path RT present";
                                          }
    
                                          leaf vrf-import-rt-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "VRFIMPORTRTPresent";
                                          }
    
                                          leaf source-asrt-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "SOURCEASRTPresent";
                                          }
    
                                          leaf source-rd-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "SOURCERDPresent";
                                          }
    
                                          leaf segmented-nexthop-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "Segmented NH attributes present for this path";
                                          }
    
                                          leaf number-of-nnh {
                                            type uint32;
                                            description
                                              "Number of Next Next Hops";
                                          }
    
                                          leaf next-hop-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NHID associated with this path";
                                          }
    
                                          leaf next-hop-id-refcount {
                                            type uint32;
                                            description
                                              "NHID references";
                                          }
    
                                          leaf ospf-area-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "OSPF area associated with the path";
                                          }
    
                                          leaf has-labelstk {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "Path has a label stack";
                                          }
    
                                          leaf num-labels {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint8;
                                            description
                                              "Number of labels in stack";
                                          }
    
                                          leaf binding-label {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "binding Label for this path";
                                          }
    
                                          leaf nhid-feid {
                                            type uint64;
                                            description
                                              "Fib nhid encap id";
                                          }
    
                                          leaf mpls-feid {
                                            type uint64;
                                            description
                                              "Fib mpls encap id";
                                          }
    
                                          leaf has-vxlan-network-id {
                                            type boolean;
                                            description
                                              "VXLAN Network Identifier exists for this path";
                                          }
    
                                          leaf vxlan-network-id {
                                            type uint32;
                                            description
                                              "VXLAN Network Identifier for this path";
                                          }
    
                                          leaf has-xcid {
                                            type boolean;
                                            description
                                              "L2 Cross Connect ID exists for this path";
                                          }
    
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf has-span-diag-interface {
                                            type boolean;
                                            description
                                              "SPAN Diagnostics Interface exists for this path";
                                          }
    
                                          leaf span-diag-interface {
                                            type xr:Interface-name;
                                            description
                                              "SPAN Diagnostics Interface for this path";
                                          }
    
                                          leaf has-subscriber-parent-interface {
                                            type boolean;
                                            description
                                              "Subscriber Parent Interface exists for this
    path";
                                          }
    
                                          leaf subscriber-parent-interface {
                                            type xr:Interface-name;
                                            description
                                              "Subscriber Parent Interface for this path";
                                          }
    
                                          leaf interface-index-present {
                                            type boolean;
                                            description
                                              "Flag to indicate if interface index attribute
    is present for this path";
                                          }
    
                                          leaf interface-index-attribute {
                                            type uint32;
                                            description
                                              "Interface Index attribute";
                                          }
    
                                          leaf iid-present {
                                            type boolean;
                                            description
                                              "Internal ID present";
                                          }
    
                                          leaf iid {
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Internal ID attribute";
                                          }
    
                                          leaf has-l2-info {
                                            type boolean;
                                            description
                                              "L2 Info present for this path";
                                          }
    
                                          list remote-backup-addr {
                                            max-elements
                                              2;
                                            description
                                              "Remote backup node address";
                                            leaf entry {
                                              xr:event-telemetry "Subscribe Telemetry Event";
                                              type Ipv4-rib-edm-addr;
                                              description
                                                "Remote backup node address";
                                            }
                                          }  // list remote-backup-addr
    
                                          list labelstk {
                                            description
                                              "Outgoing label stack for this path";
                                            leaf entry {
                                              xr:event-telemetry "Subscribe Telemetry Event";
                                              type uint32;
                                              description
                                                "Outgoing label stack for this path";
                                            }
                                          }  // list labelstk
    
                                          list next-next-hop {
                                            description
                                              "List of Next Next Hops";
                                            leaf type {
                                              type Rib-edm-nnh;
                                              description
                                                "type";
                                            }
    
                                            leaf unknownval {
                                              when
                                                "../type = 'unknown'" {
                                                description
                                                  "../type = 'Unknown'";
                                              }
                                              type uint32;
                                              description
                                                "Unknown Value";
                                            }
    
                                            leaf address {
                                              when
                                                "../type = 'ipv4-address'" {
                                                description
                                                  "../type = 'IPv4Address'";
                                              }
                                              type inet:ipv4-address;
                                              description
                                                "IPv4 Address";
                                            }
    
                                            leaf interface-index {
                                              when
                                                "../type = 'if-index'" {
                                                description
                                                  "../type = 'IfIndex'";
                                              }
                                              type uint32;
                                              description
                                                "Interface Index";
                                            }
                                          }  // list next-next-hop
                                        }  // list ipv4-rib-edm-path
                                      }  // container route-path
    
                                      leaf prefix {
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Route prefix";
                                      }
    
                                      leaf prefix-length-xr {
                                        type uint8;
                                        description
                                          "Length of prefix";
                                      }
    
                                      leaf route-version {
                                        type uint32;
                                        description
                                          "Route version, incremented by one on each active
    route change";
                                      }
    
                                      leaf protocol-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Protocol advertising the route";
                                      }
    
                                      leaf protocol-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          " Name of Protocol";
                                      }
    
                                      leaf instance {
                                        type string;
                                        description
                                          "Instance name";
                                      }
    
                                      leaf client-id {
                                        type uint32;
                                        description
                                          "Client adding the route to RIB";
                                      }
    
                                      leaf route-type {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint16;
                                        description
                                          "Type of route installed in RIB";
                                      }
    
                                      leaf priority {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Route priority";
                                      }
    
                                      leaf svd-type {
                                        type uint8;
                                        description
                                          "SVD Type of route";
                                      }
    
                                      leaf l2-route-type {
                                        type uint8;
                                        description
                                          "Type of route associated with L2 Service";
                                      }
    
                                      leaf flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Route flags";
                                      }
    
                                      leaf extended-flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint64;
                                        description
                                          "Extended Route flags";
                                      }
    
                                      leaf tag {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Opaque proto specific info";
                                      }
    
                                      leaf distance {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Distance of the route";
                                      }
    
                                      leaf diversion-distance {
                                        type uint32;
                                        description
                                          "Diversion distance of the route";
                                      }
    
                                      leaf metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Route metric";
                                      }
    
                                      leaf paths-count {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Number of paths";
                                      }
    
                                      leaf attribute-identity {
                                        type uint32;
                                        description
                                          "BGP Attribute ID";
                                      }
    
                                      leaf traffic-index {
                                        type uint8;
                                        description
                                          "BGP Traffic Index";
                                      }
    
                                      leaf route-precedence {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "IP precedence for this route";
                                      }
    
                                      leaf qos-group {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Route qos group";
                                      }
    
                                      leaf flow-tag {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Flow tag for this route";
                                      }
    
                                      leaf fwd-class {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Forward Class";
                                      }
    
                                      leaf pic-count {
                                        type uint8;
                                        description
                                          "Number of pic paths in this route";
                                      }
    
                                      leaf active {
                                        type boolean;
                                        description
                                          "Is the route active or backup";
                                      }
    
                                      leaf diversion {
                                        type boolean;
                                        description
                                          "Route has a diversion path";
                                      }
    
                                      leaf diversion-proto-name {
                                        type string;
                                        description
                                          "Diversion route protocol name";
                                      }
    
                                      leaf route-age {
                                        type uint32;
                                        units
                                          "second";
                                        description
                                          "Age of route (seconds)";
                                      }
    
                                      leaf route-label {
                                        type uint32;
                                        description
                                          "Local label of the route";
                                      }
    
                                      leaf version {
                                        type uint32;
                                        description
                                          "Route Version";
                                      }
    
                                      leaf tbl-version {
                                        type uint64;
                                        description
                                          "Table Version";
                                      }
    
                                      leaf route-modify-time {
                                        type uint64;
                                        units
                                          "nanosecond";
                                        description
                                          "Route modification time(nanoseconds)";
                                      }
    
                                      leaf prefix-feid {
                                        type uint64;
                                        description
                                          "Fib per-prefix encap id";
                                      }
    
                                      leaf number-of-algorithm-labels {
                                        type uint16;
                                        description
                                          "Number of Algorithm Labels associated with this
    prefix";
                                      }
    
                                      list algorithm-label {
                                        description
                                          "List of Algorithm Labels associated with this
    Prefix";
                                        leaf algorithm-id {
                                          type uint8;
                                          description
                                            "Algorithm Identifier";
                                        }
    
                                        leaf label {
                                          type uint32;
                                          description
                                            "Local label";
                                        }
    
                                        leaf metric {
                                          type uint32;
                                          description
                                            "Route Metric associated with Algorithm
    Identifier";
                                        }
                                      }  // list algorithm-label
                                    }  // list dest-backup-route
                                  }  // container dest-backup-routes
    
                                  leaf address {
                                    type inet:ipv4-address-no-zone;
                                    description
                                      "Backup network address";
                                  }
    
                                  leaf prefix-length {
                                    type xr:Ipv4-prefix-length;
                                    description
                                      "prefix length of the backup network
    address";
                                  }
                                }  // list dest-backup-prefix
                              }  // container dest-backup-prefixes
                            }  // container dest-backup-kw
    
                            container dest-next-hop-routes {
                              description
                                "Resolving next hop";
                              list dest-next-hop-route {
                                key "address";
                                description
                                  "Nexthop information for a specific
    address";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-next-hop-route
                            }  // container dest-next-hop-routes
                          }  // container destination-kw
    
                          container protocol {
                            description
                              "Contains the classification of routes by
    protocol";
                            container mobile {
                              description
                                "Mobile Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container mobile
    
                            container subscriber {
                              description
                                "Subscriber Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container subscriber
    
                            container connected {
                              description
                                "Connected Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container connected
    
                            container dagr {
                              description
                                "DAGR Protocol(Direct-Attached Gateway
    Redundancy) Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container dagr
    
                            container rip {
                              description
                                "RIP Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container rip
    
                            container ospf {
                              description
                                "OSPF Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container ospf
    
                            container srv6-local {
                              description
                                "SRv6-Local Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container srv6-local
    
                            container static {
                              description
                                "Static Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container static
    
                            container rpl {
                              description
                                "RPL Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container rpl
    
                            container application {
                              description
                                "Application Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container application
    
                            container te-client {
                              description
                                "TEClient Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container te-client
    
                            container eigrp {
                              description
                                "EIGRP Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container eigrp
    
                            container local {
                              description
                                "Local Protocol";
                              container smiap {
                                description
                                  "SMIAP";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container smiap
    
                              container lspv {
                                description
                                  "LSPV(Label Switched Path Verification)
    Protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container lspv
    
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container local
    
                            container bgp {
                              description
                                "BGP Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container bgp
    
                            container isis {
                              description
                                "ISIS Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container isis
                          }  // container protocol
    
                          container opaques {
                            description
                              "Opaque information ";
                            list opaque {
                              description
                                "Opaque item ";
                              leaf opaque-client-id {
                                type uint32 {
                                  range
                                    "0..2501";
                                }
                                description
                                  "Opaque Client ID";
                              }
    
                              leaf opaque-proto-id {
                                type uint32 {
                                  range "0..96";
                                }
                                description
                                  "Opaque Proto ID";
                              }
    
                              leaf opaque-key-type {
                                type uint32 {
                                  range "0..16";
                                }
                                description
                                  "The type of the opaque key installed
    in the RIB table";
                              }
    
                              leaf opaque-key-size {
                                type uint32 {
                                  range
                                    "0..4294967295";
                                }
                                description
                                  "The size of the opaque key installed
    in the RIB table";
                              }
    
                              leaf opaque-data-size {
                                type uint32 {
                                  range
                                    "0..4294967295";
                                }
                                description
                                  "The size of the opaque data installed
    in the RIB table";
                              }
    
                              leaf opaque-string {
                                type xr:Cisco-ios-xr-string;
                                description
                                  "The opaque data installed in the RIB
    table";
                              }
    
                              leaf key {
                                type yang:hex-string;
                                description
                                  "The unique ID assigned to the opaque object by
    client";
                              }
    
                              leaf data {
                                type yang:hex-string;
                                description
                                  "The data part of the opaque object";
                              }
                            }  // list opaque
                          }  // container opaques
    
                          container q-routes {
                            description
                              "Quarantine";
                            list q-route {
                              key "address prefix-length";
                              description
                                "Route information for a specific
    quarantined address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Quarantined network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the quarantined
    network address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list q-route
                          }  // container q-routes
    
                          container longer-route-prefixes {
                            description
                              "Longer routes prefix table";
                            list longer-route-prefix {
                              description
                                "Net/mask to match longer routes";
                              container longer-route-last-prefixes {
                                description
                                  "Longer route last prefix table";
                                list longer-route-last-prefix {
                                  description
                                    "Information of all matching longer
    routes for a prefix/mask under a
    given table";
                                  leaf address {
                                    type inet:ipv4-address-no-zone;
                                    description
                                      "Network Address ";
                                  }
    
                                  leaf prefix-length {
                                    type xr:Ipv4-prefix-length;
                                    description
                                      "Prefix Length ";
                                  }
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-endpoint-behavior {
                                      description
                                        "SRv6 Endpoint behavior/type";
                                      leaf type {
                                        type Mgmt-srv6-endpoint;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-endpoint-behavior
    
                                    container srv6-format {
                                      description
                                        "SRv6 Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-format
    
                                    leaf is-srv6-endpoint {
                                      type boolean;
                                      description
                                        "Route is an SRv6 Endpoint (local SID)";
                                    }
    
                                    leaf is-srv6-locator {
                                      type boolean;
                                      description
                                        "Route corresponds to an SRv6 remote locator";
                                    }
    
                                    leaf srv6-locator-algo {
                                      type uint8;
                                      description
                                        "SRv6 Algo corresponding to SRv6 remote locator";
                                    }
                                  }  // container srv6-info
    
                                  container route-path {
                                    description
                                      "Path(s) of the route";
                                    list ipv4-rib-edm-path {
                                      description
                                        "Next path";
                                      container l2-info {
                                        description
                                          "L2 Info for this path";
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf ac-interface {
                                          type xr:Interface-name;
                                          description
                                            "L2 AC Interface";
                                        }
                                      }  // container l2-info
    
                                      container srv6-info {
                                        description
                                          "SRv6 related information";
                                        container srv6-carrier-format {
                                          description
                                            "SRv6 Carrier Format";
                                          leaf type {
                                            type Mgmt-srv6-sid-fmt;
                                            description
                                              "Format type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Format description";
                                          }
                                        }  // container srv6-carrier-format
    
                                        container srv6-headend-behavior {
                                          description
                                            "SRv6 headend behavior/type info";
                                          leaf type {
                                            type Mgmt-srv6-headend;
                                            description
                                              "Behavior type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Behavior description";
                                          }
                                        }  // container srv6-headend-behavior
    
                                        container via-srv6-sid {
                                          description
                                            "Via-SRv6-SID value";
                                          leaf sid {
                                            type inet:ipv6-address;
                                            description
                                              "Via-SRv6-SID value";
                                          }
    
                                          leaf resolution-length {
                                            type uint8;
                                            description
                                              "FIB Resolution length";
                                          }
                                        }  // container via-srv6-sid
    
                                        leaf number-of-srv6-carriers {
                                          type uint8;
                                          description
                                            "Number of SRv6 Carriers";
                                        }
    
                                        leaf has-srv6-headend-behavior {
                                          type boolean;
                                          description
                                            "Path has some SRv6 head-end behavior associated";
                                        }
    
                                        leaf has-via-srv6-sid {
                                          type boolean;
                                          description
                                            "Via-SRv6-SID is present";
                                        }
    
                                        list srv6-carrier {
                                          description
                                            "List of SRv6 Carriers with one or more SIDs";
                                          leaf sid {
                                            type inet:ipv6-address;
                                            description
                                              "SID value";
                                          }
                                        }  // list srv6-carrier
                                      }  // container srv6-info
    
                                      leaf address {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Nexthop";
                                      }
    
                                      leaf information-source {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Infosource";
                                      }
    
                                      leaf v6-nexthop {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type inet:ipv6-address;
                                        description
                                          "IPv6 nexthop for v4 over v6";
                                      }
    
                                      leaf v6-information-source {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type inet:ipv6-address;
                                        description
                                          "V6 Infosource";
                                      }
    
                                      leaf interface-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type xr:Interface-name;
                                        description
                                          "Interface handle for the path's nexthop";
                                      }
    
                                      leaf metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Metrics";
                                      }
    
                                      leaf load-metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Load Metrics";
                                      }
    
                                      leaf flags64 {
                                        type uint64;
                                        description
                                          "Flags extended to 64 bits";
                                      }
    
                                      leaf flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint16;
                                        description
                                          "Flags";
                                      }
    
                                      leaf private-flags {
                                        type uint16;
                                        description
                                          "Private Flags, used internally by RIB";
                                      }
    
                                      leaf minimum-recurse-length {
                                        type uint8;
                                        description
                                          "Minimum netmask length of recursive resolving
    route";
                                      }
    
                                      leaf looped {
                                        type boolean;
                                        description
                                          "Looping path";
                                      }
    
                                      leaf next-hop-table-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "The table to which the next hop belongs";
                                      }
    
                                      leaf next-hop-vrf-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "VRF Name of the nh table";
                                      }
    
                                      leaf next-hop-table-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "NH table name";
                                      }
    
                                      leaf next-hop-afi {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NH afi";
                                      }
    
                                      leaf next-hop-safi {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NH safi";
                                      }
    
                                      leaf route-label {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Label associated with this path";
                                      }
    
                                      leaf tunnel-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Tunnel ID associated with this path";
                                      }
    
                                      leaf pathid {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Path id of this path";
                                      }
    
                                      leaf backup-pathid {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Path id of this path's backup";
                                      }
    
                                      leaf ref-cnt-of-backup {
                                        type uint32;
                                        description
                                          "For backup paths, the number of active paths
    protected by the backup path";
                                      }
    
                                      leaf number-of-extended-communities {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Number of extended communities associated with
    this path";
                                      }
    
                                      leaf mvpn-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "MVPN attribute present";
                                      }
    
                                      leaf path-rt-present {
                                        type boolean;
                                        description
                                          "Path RT present";
                                      }
    
                                      leaf vrf-import-rt-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "VRFIMPORTRTPresent";
                                      }
    
                                      leaf source-asrt-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "SOURCEASRTPresent";
                                      }
    
                                      leaf source-rd-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "SOURCERDPresent";
                                      }
    
                                      leaf segmented-nexthop-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "Segmented NH attributes present for this path";
                                      }
    
                                      leaf number-of-nnh {
                                        type uint32;
                                        description
                                          "Number of Next Next Hops";
                                      }
    
                                      leaf next-hop-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NHID associated with this path";
                                      }
    
                                      leaf next-hop-id-refcount {
                                        type uint32;
                                        description
                                          "NHID references";
                                      }
    
                                      leaf ospf-area-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "OSPF area associated with the path";
                                      }
    
                                      leaf has-labelstk {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "Path has a label stack";
                                      }
    
                                      leaf num-labels {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Number of labels in stack";
                                      }
    
                                      leaf binding-label {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "binding Label for this path";
                                      }
    
                                      leaf nhid-feid {
                                        type uint64;
                                        description
                                          "Fib nhid encap id";
                                      }
    
                                      leaf mpls-feid {
                                        type uint64;
                                        description
                                          "Fib mpls encap id";
                                      }
    
                                      leaf has-vxlan-network-id {
                                        type boolean;
                                        description
                                          "VXLAN Network Identifier exists for this path";
                                      }
    
                                      leaf vxlan-network-id {
                                        type uint32;
                                        description
                                          "VXLAN Network Identifier for this path";
                                      }
    
                                      leaf has-xcid {
                                        type boolean;
                                        description
                                          "L2 Cross Connect ID exists for this path";
                                      }
    
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf has-span-diag-interface {
                                        type boolean;
                                        description
                                          "SPAN Diagnostics Interface exists for this path";
                                      }
    
                                      leaf span-diag-interface {
                                        type xr:Interface-name;
                                        description
                                          "SPAN Diagnostics Interface for this path";
                                      }
    
                                      leaf has-subscriber-parent-interface {
                                        type boolean;
                                        description
                                          "Subscriber Parent Interface exists for this
    path";
                                      }
    
                                      leaf subscriber-parent-interface {
                                        type xr:Interface-name;
                                        description
                                          "Subscriber Parent Interface for this path";
                                      }
    
                                      leaf interface-index-present {
                                        type boolean;
                                        description
                                          "Flag to indicate if interface index attribute
    is present for this path";
                                      }
    
                                      leaf interface-index-attribute {
                                        type uint32;
                                        description
                                          "Interface Index attribute";
                                      }
    
                                      leaf iid-present {
                                        type boolean;
                                        description
                                          "Internal ID present";
                                      }
    
                                      leaf iid {
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Internal ID attribute";
                                      }
    
                                      leaf has-l2-info {
                                        type boolean;
                                        description
                                          "L2 Info present for this path";
                                      }
    
                                      list remote-backup-addr {
                                        max-elements
                                          2;
                                        description
                                          "Remote backup node address";
                                        leaf entry {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Remote backup node address";
                                        }
                                      }  // list remote-backup-addr
    
                                      list labelstk {
                                        description
                                          "Outgoing label stack for this path";
                                        leaf entry {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Outgoing label stack for this path";
                                        }
                                      }  // list labelstk
    
                                      list next-next-hop {
                                        description
                                          "List of Next Next Hops";
                                        leaf type {
                                          type Rib-edm-nnh;
                                          description
                                            "type";
                                        }
    
                                        leaf unknownval {
                                          when
                                            "../type = 'unknown'" {
                                            description
                                              "../type = 'Unknown'";
                                          }
                                          type uint32;
                                          description
                                            "Unknown Value";
                                        }
    
                                        leaf address {
                                          when
                                            "../type = 'ipv4-address'" {
                                            description
                                              "../type = 'IPv4Address'";
                                          }
                                          type inet:ipv4-address;
                                          description
                                            "IPv4 Address";
                                        }
    
                                        leaf interface-index {
                                          when
                                            "../type = 'if-index'" {
                                            description
                                              "../type = 'IfIndex'";
                                          }
                                          type uint32;
                                          description
                                            "Interface Index";
                                        }
                                      }  // list next-next-hop
                                    }  // list ipv4-rib-edm-path
                                  }  // container route-path
    
                                  leaf prefix {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Route prefix";
                                  }
    
                                  leaf prefix-length-xr {
                                    type uint8;
                                    description
                                      "Length of prefix";
                                  }
    
                                  leaf route-version {
                                    type uint32;
                                    description
                                      "Route version, incremented by one on each active
    route change";
                                  }
    
                                  leaf protocol-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Protocol advertising the route";
                                  }
    
                                  leaf protocol-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      " Name of Protocol";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name";
                                  }
    
                                  leaf client-id {
                                    type uint32;
                                    description
                                      "Client adding the route to RIB";
                                  }
    
                                  leaf route-type {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Type of route installed in RIB";
                                  }
    
                                  leaf priority {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Route priority";
                                  }
    
                                  leaf svd-type {
                                    type uint8;
                                    description
                                      "SVD Type of route";
                                  }
    
                                  leaf l2-route-type {
                                    type uint8;
                                    description
                                      "Type of route associated with L2 Service";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Route flags";
                                  }
    
                                  leaf extended-flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint64;
                                    description
                                      "Extended Route flags";
                                  }
    
                                  leaf tag {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Opaque proto specific info";
                                  }
    
                                  leaf distance {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Distance of the route";
                                  }
    
                                  leaf diversion-distance {
                                    type uint32;
                                    description
                                      "Diversion distance of the route";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Route metric";
                                  }
    
                                  leaf paths-count {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of paths";
                                  }
    
                                  leaf attribute-identity {
                                    type uint32;
                                    description
                                      "BGP Attribute ID";
                                  }
    
                                  leaf traffic-index {
                                    type uint8;
                                    description
                                      "BGP Traffic Index";
                                  }
    
                                  leaf route-precedence {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "IP precedence for this route";
                                  }
    
                                  leaf qos-group {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Route qos group";
                                  }
    
                                  leaf flow-tag {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Flow tag for this route";
                                  }
    
                                  leaf fwd-class {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Forward Class";
                                  }
    
                                  leaf pic-count {
                                    type uint8;
                                    description
                                      "Number of pic paths in this route";
                                  }
    
                                  leaf active {
                                    type boolean;
                                    description
                                      "Is the route active or backup";
                                  }
    
                                  leaf diversion {
                                    type boolean;
                                    description
                                      "Route has a diversion path";
                                  }
    
                                  leaf diversion-proto-name {
                                    type string;
                                    description
                                      "Diversion route protocol name";
                                  }
    
                                  leaf route-age {
                                    type uint32;
                                    units
                                      "second";
                                    description
                                      "Age of route (seconds)";
                                  }
    
                                  leaf route-label {
                                    type uint32;
                                    description
                                      "Local label of the route";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Route Version";
                                  }
    
                                  leaf tbl-version {
                                    type uint64;
                                    description
                                      "Table Version";
                                  }
    
                                  leaf route-modify-time {
                                    type uint64;
                                    units
                                      "nanosecond";
                                    description
                                      "Route modification time(nanoseconds)";
                                  }
    
                                  leaf prefix-feid {
                                    type uint64;
                                    description
                                      "Fib per-prefix encap id";
                                  }
    
                                  leaf number-of-algorithm-labels {
                                    type uint16;
                                    description
                                      "Number of Algorithm Labels associated with this
    prefix";
                                  }
    
                                  list algorithm-label {
                                    description
                                      "List of Algorithm Labels associated with this
    Prefix";
                                    leaf algorithm-id {
                                      type uint8;
                                      description
                                        "Algorithm Identifier";
                                    }
    
                                    leaf label {
                                      type uint32;
                                      description
                                        "Local label";
                                    }
    
                                    leaf metric {
                                      type uint32;
                                      description
                                        "Route Metric associated with Algorithm
    Identifier";
                                    }
                                  }  // list algorithm-label
                                }  // list longer-route-last-prefix
                              }  // container longer-route-last-prefixes
    
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Network Address ";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix Length ";
                              }
                            }  // list longer-route-prefix
                          }  // container longer-route-prefixes
    
                          container nexthops {
                            description
                              "Nexthop notification registerations
    under a given table";
                            list nexthop {
                              description
                                "List the nexthop notification
    registeration under a given table";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Nexthop network address ";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the nexthop network
    address";
                              }
    
                              leaf unresolved-nh-tree {
                                type boolean;
                                description
                                  "Unresolved Nexthop Tree";
                              }
    
                              leaf exact-match {
                                type boolean;
                                description
                                  "Exact match";
                              }
    
                              leaf allow-default {
                                type boolean;
                                description
                                  "Allow Default";
                              }
    
                              leaf recurse {
                                type boolean;
                                description
                                  "Recurse";
                              }
    
                              leaf cross-table {
                                type boolean;
                                description
                                  "Cross table nextHop";
                              }
    
                              leaf pack-sfs {
                                type boolean;
                                description
                                  "Pack SFS paths for Multicast";
                              }
    
                              leaf pack-backup-paths {
                                type boolean;
                                description
                                  "Pack backup paths";
                              }
    
                              leaf backup-route {
                                type boolean;
                                description
                                  "Backup route notifications";
                              }
    
                              leaf best-metric {
                                type boolean;
                                description
                                  "Return lowest metric";
                              }
    
                              container clients {
                                description
                                  "Client(s) of the address";
                                list rib-edm-nh-client {
                                  description
                                    "Next client";
                                  leaf id {
                                    type uint32;
                                    description
                                      "Client id";
                                  }
    
                                  leaf ref-count {
                                    type uint32;
                                    description
                                      "The number NH reference this client";
                                  }
    
                                  leaf nh-create-age {
                                    type uint32;
                                    description
                                      "How long has client has been created";
                                  }
    
                                  leaf nh-create-time {
                                    type uint64;
                                    description
                                      "Client creation time";
                                  }
    
                                  leaf nh-read-age {
                                    type uint32;
                                    description
                                      "How long ago client read this notification";
                                  }
    
                                  leaf nh-read-time {
                                    type uint64;
                                    description
                                      "Client notification read time";
                                  }
    
                                  leaf pack-mvpn {
                                    type boolean;
                                    description
                                      "Pack MVPN";
                                  }
    
                                  leaf pack-path-rt {
                                    type boolean;
                                    description
                                      "Pack path RT";
                                  }
    
                                  leaf pack-vrf-import-rt {
                                    type boolean;
                                    description
                                      "Pack VRF import RT";
                                  }
    
                                  leaf pack-source-as-rt {
                                    type boolean;
                                    description
                                      "Pack source AS RT";
                                  }
    
                                  leaf pack-source-rd {
                                    type boolean;
                                    description
                                      "Pack source RD";
                                  }
    
                                  leaf pack-mldp-root {
                                    type boolean;
                                    description
                                      "Pack MLDP root";
                                  }
    
                                  leaf pack-seg-nh {
                                    type boolean;
                                    description
                                      "Pack seg NH";
                                  }
    
                                  leaf notify-reregister {
                                    type boolean;
                                    description
                                      "Notify Reregister";
                                  }
                                }  // list rib-edm-nh-client
                              }  // container clients
    
                              container resolved-route {
                                description
                                  "Route resolved this nexthop";
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // container resolved-route
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-len {
                                type uint32;
                                description
                                  "Length of prefix";
                              }
    
                              leaf dest-addr {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Destination address";
                              }
    
                              leaf dest-intf {
                                type uint32;
                                description
                                  "Destination interface";
                              }
    
                              leaf dest-tableid {
                                type uint32;
                                description
                                  "Destination tableid";
                              }
    
                              leaf dest-metric {
                                type uint32;
                                description
                                  "Destination metric";
                              }
    
                              leaf dest-vrf-name {
                                type string;
                                description
                                  "VRF Name of the nh table";
                              }
    
                              leaf damped {
                                type boolean;
                                description
                                  "Nexthop being damped?";
                              }
    
                              leaf exact-match-xr {
                                type boolean;
                                description
                                  "Exact match";
                              }
    
                              leaf allow-default-xr {
                                type boolean;
                                description
                                  "Allow default flag";
                              }
    
                              leaf recurse-xr {
                                type boolean;
                                description
                                  "Allow recurse flag";
                              }
    
                              leaf xtable {
                                type boolean;
                                description
                                  "Cross table nexthop";
                              }
    
                              leaf pack-sf-xr {
                                type boolean;
                                description
                                  "Pack SFS paths for multicast";
                              }
    
                              leaf pack-backup {
                                type boolean;
                                description
                                  "Pack backup paths";
                              }
    
                              leaf backup-route-xr {
                                type boolean;
                                description
                                  "Backup route notifications";
                              }
    
                              leaf best-metric-xr {
                                type boolean;
                                description
                                  "Return lowest metric for dest. metric";
                              }
    
                              leaf unres-nh-tree {
                                type boolean;
                                description
                                  "Context about which tree the server should walk";
                              }
    
                              leaf flags {
                                type uint16;
                                description
                                  "nh_entry flags";
                              }
    
                              leaf dest-path-count {
                                type uint32;
                                description
                                  "Number of destination paths";
                              }
    
                              leaf accrued-penalty {
                                type uint16;
                                description
                                  "Damped accured penalty";
                              }
    
                              leaf expiration-age {
                                type uint32;
                                description
                                  "How soon the nexthop is undamped";
                              }
    
                              leaf expiration-time {
                                type uint64;
                                description
                                  "Time where the first is undamped";
                              }
    
                              leaf min-damped-threshold {
                                type uint32;
                                description
                                  "Minimum damped threshold";
                              }
    
                              leaf max-damped-penalty {
                                type uint32;
                                description
                                  "Maximum damped threshold";
                              }
    
                              leaf decay-rate {
                                type uint32;
                                description
                                  "Damped decay rate";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Event version";
                              }
    
                              leaf last-event-age {
                                type uint32;
                                description
                                  "How long since last event occured";
                              }
    
                              leaf last-event-time {
                                type uint64;
                                description
                                  "Time at which last event occured";
                              }
    
                              list dest-path {
                                description
                                  "Path(s) of the route";
                                leaf interface {
                                  type uint32;
                                  description
                                    "interface";
                                }
    
                                leaf address {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Address";
                                }
    
                                leaf tableid {
                                  type uint32;
                                  description
                                    "tableid";
                                }
    
                                leaf vrf-name {
                                  type string;
                                  description
                                    "VRF Name of the nh table";
                                }
                              }  // list dest-path
                            }  // list nexthop
                          }  // container nexthops
    
                          container backup-routes {
                            description
                              "Backup route information for the given
    table";
                            list backup-route {
                              key "address prefix-length protoid";
                              description
                                "Route information for a specific backup
    address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Backup network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the backup network
    address";
                              }
    
                              leaf protoid {
                                type uint32 {
                                  range "0..96";
                                }
                                description
                                  "Proto ID";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list backup-route
                          }  // container backup-routes
    
                          container adverts-list {
                            description
                              "Route advertiser information ";
                            container advert-prefixes {
                              description
                                "Route advertiser prefix table";
                              list advert-prefix {
                                key "address prefix-length";
                                description
                                  "Route advertiser information of a
    specific Network Address ";
                                container adverts {
                                  description
                                    "Route advertiser table";
                                  list advert {
                                    key "protoid";
                                    description
                                      "Route advertiser information of a
    specific Network Address and Client";
                                    leaf protoid {
                                      type uint32 {
                                        range
                                          "0..96";
                                      }
                                      description
                                        "Proto ID";
                                    }
    
                                    list ipv4-rib-edm-advert {
                                      description
                                        "Next advertising proto";
                                      leaf protocol-id {
                                        type uint32;
                                        description
                                          "Protocol advertising the route";
                                      }
    
                                      leaf client-id {
                                        type uint32;
                                        description
                                          "  Client advertising the route";
                                      }
    
                                      leaf number-of-extended-communities {
                                        type uint32;
                                        description
                                          "Number of extended communities attached by
    advertiser";
                                      }
    
                                      leaf extended-communities {
                                        type yang:hex-string;
                                        description
                                          "Extended communities attached by the advertiser";
                                      }
    
                                      leaf protocol-opaque-flags {
                                        type uint8;
                                        description
                                          "OSPF area-id flags";
                                      }
    
                                      leaf protocol-opaque {
                                        type uint32;
                                        description
                                          "OSPF area-id";
                                      }
    
                                      leaf code {
                                        type int8;
                                        description
                                          "Protocol code";
                                      }
    
                                      leaf instance-name {
                                        type string {
                                          length
                                            "0..41";
                                        }
                                        description
                                          "Instance name of the protocol advertising the
    route";
                                      }
                                    }  // list ipv4-rib-edm-advert
                                  }  // list advert
                                }  // container adverts
    
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                leaf prefix-length {
                                  type xr:Ipv4-prefix-length;
                                  description
                                    "Prefix length of the network address";
                                }
                              }  // list advert-prefix
                            }  // container advert-prefixes
                          }  // container adverts-list
    
                          leaf route-table-name {
                            type xr:Cisco-ios-xr-string;
                            description
                              "Name of the route table";
                          }
                        }  // list ip-rib-route-table-name
                      }  // container ip-rib-route-table-names
    
                      leaf saf-name {
                        type Rib-saf-name;
                        description
                          "Name of the SAF";
                      }
                    }  // list saf
                  }  // container safs
    
                  leaf af-name {
                    type Rib-af-name;
                    description "Name of the AF";
                  }
                }  // list af
              }  // container afs
    
              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description "Name of the VRF";
              }
            }  // list vrf
          }  // container vrfs
    
          container rib-table-ids {
            description "RIB table";
            list rib-table-id {
              key "tableid";
              description "Specific Table";
              container summary-protos {
                description "RIB table summary";
                list summary-proto {
                  key "protoid";
                  description
                    "Route summary information for a specific
    table/protocol ";
                  leaf protoid {
                    type uint32 {
                      range "0..96";
                    }
                    description "Proto ID";
                  }
    
                  container proto-route-count {
                    description
                      "Count for proto. instance";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container proto-route-count
    
                  container rtype-none {
                    description "No route type";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-none
    
                  container rtype-other {
                    description
                      "Unknown route type";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-other
    
                  container rtype-ospf-intra {
                    description
                      "OSPF route within an area";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-intra
    
                  container rtype-ospf-inter {
                    description
                      "OSPF route across diff. areas";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-inter
    
                  container rtype-ospf-extern1 {
                    description
                      "OSPF external route of type 1";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-extern1
    
                  container rtype-ospf-extern2 {
                    description
                      "OSPF external route of type 2";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-extern2
    
                  container rtype-isis-sum {
                    description
                      "IS-IS summary route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-sum
    
                  container rtype-isis-l1 {
                    description
                      "IS-IS level 1 route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l1
    
                  container rtype-isis-l2 {
                    description
                      "IS-IS level 2 route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l2
    
                  container rtype-isis-l1-ia {
                    description
                      "IS-IS level1 inter-area route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l1-ia
    
                  container rtype-bgp-int {
                    description "iBGP route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-int
    
                  container rtype-bgp-ext {
                    description "eBGP route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-ext
    
                  container rtype-bgp-loc {
                    description
                      "BGP local route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-loc
    
                  container rtype-ospf-nssa1 {
                    description
                      "OSPF NSSA ext. route type 1";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-nssa1
    
                  container rtype-ospf-nssa2 {
                    description
                      "OSPF NSSA ext. route type 2";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-nssa2
    
                  container rtype-igrp2-int {
                    description
                      "EIGRP internal route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-igrp2-int
    
                  container rtype-igrp2-ext {
                    description
                      "EIGRP external route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-igrp2-ext
    
                  leaf name {
                    type string;
                    description "Proto name";
                  }
    
                  leaf instance {
                    type string;
                    description
                      "Instance name of the protocol";
                  }
                }  // list summary-proto
              }  // container summary-protos
    
              container rib-table-itf-hndls {
                description
                  "RIB table interface";
                list rib-table-itf-hndl {
                  key "handle";
                  description "Interface handle";
                  leaf handle {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description "Itf Handle";
                  }
    
                  list itf-route {
                    key "address";
                    description
                      "Route information for a specific
    table/interface ";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "Network Address";
                    }
    
                    container srv6-info {
                      description
                        "SRv6 related information";
                      container srv6-endpoint-behavior {
                        description
                          "SRv6 Endpoint behavior/type";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }
    
                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-endpoint-behavior
    
                      container srv6-format {
                        description
                          "SRv6 Format";
                        leaf type {
                          type Mgmt-srv6-sid-fmt;
                          description
                            "Format type";
                        }
    
                        leaf description {
                          type string;
                          description
                            "Format description";
                        }
                      }  // container srv6-format
    
                      leaf is-srv6-endpoint {
                        type boolean;
                        description
                          "Route is an SRv6 Endpoint (local SID)";
                      }
    
                      leaf is-srv6-locator {
                        type boolean;
                        description
                          "Route corresponds to an SRv6 remote locator";
                      }
    
                      leaf srv6-locator-algo {
                        type uint8;
                        description
                          "SRv6 Algo corresponding to SRv6 remote locator";
                      }
                    }  // container srv6-info
    
                    container route-path {
                      description
                        "Path(s) of the route";
                      list ipv4-rib-edm-path {
                        description "Next path";
                        container l2-info {
                          description
                            "L2 Info for this path";
                          leaf xcid {
                            type uint32;
                            description
                              "L2 Cross Connect ID for this path";
                          }
    
                          leaf ac-interface {
                            type xr:Interface-name;
                            description
                              "L2 AC Interface";
                          }
                        }  // container l2-info
    
                        container srv6-info {
                          description
                            "SRv6 related information";
                          container srv6-carrier-format {
                            description
                              "SRv6 Carrier Format";
                            leaf type {
                              type Mgmt-srv6-sid-fmt;
                              description
                                "Format type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Format description";
                            }
                          }  // container srv6-carrier-format
    
                          container srv6-headend-behavior {
                            description
                              "SRv6 headend behavior/type info";
                            leaf type {
                              type Mgmt-srv6-headend;
                              description
                                "Behavior type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-headend-behavior
    
                          container via-srv6-sid {
                            description
                              "Via-SRv6-SID value";
                            leaf sid {
                              type inet:ipv6-address;
                              description
                                "Via-SRv6-SID value";
                            }
    
                            leaf resolution-length {
                              type uint8;
                              description
                                "FIB Resolution length";
                            }
                          }  // container via-srv6-sid
    
                          leaf number-of-srv6-carriers {
                            type uint8;
                            description
                              "Number of SRv6 Carriers";
                          }
    
                          leaf has-srv6-headend-behavior {
                            type boolean;
                            description
                              "Path has some SRv6 head-end behavior associated";
                          }
    
                          leaf has-via-srv6-sid {
                            type boolean;
                            description
                              "Via-SRv6-SID is present";
                          }
    
                          list srv6-carrier {
                            description
                              "List of SRv6 Carriers with one or more SIDs";
                            leaf sid {
                              type inet:ipv6-address;
                              description
                                "SID value";
                            }
                          }  // list srv6-carrier
                        }  // container srv6-info
    
                        leaf address {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type Ipv4-rib-edm-addr;
                          description "Nexthop";
                        }
    
                        leaf information-source {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type Ipv4-rib-edm-addr;
                          description
                            "Infosource";
                        }
    
                        leaf v6-nexthop {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type inet:ipv6-address;
                          description
                            "IPv6 nexthop for v4 over v6";
                        }
    
                        leaf v6-information-source {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type inet:ipv6-address;
                          description
                            "V6 Infosource";
                        }
    
                        leaf interface-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type xr:Interface-name;
                          description
                            "Interface handle for the path's nexthop";
                        }
    
                        leaf metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "Metrics";
                        }
    
                        leaf load-metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Load Metrics";
                        }
    
                        leaf flags64 {
                          type uint64;
                          description
                            "Flags extended to 64 bits";
                        }
    
                        leaf flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint16;
                          description "Flags";
                        }
    
                        leaf private-flags {
                          type uint16;
                          description
                            "Private Flags, used internally by RIB";
                        }
    
                        leaf minimum-recurse-length {
                          type uint8;
                          description
                            "Minimum netmask length of recursive resolving
    route";
                        }
    
                        leaf looped {
                          type boolean;
                          description
                            "Looping path";
                        }
    
                        leaf next-hop-table-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "The table to which the next hop belongs";
                        }
    
                        leaf next-hop-vrf-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "VRF Name of the nh table";
                        }
    
                        leaf next-hop-table-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "NH table name";
                        }
    
                        leaf next-hop-afi {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "NH afi";
                        }
    
                        leaf next-hop-safi {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "NH safi";
                        }
    
                        leaf route-label {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Label associated with this path";
                        }
    
                        leaf tunnel-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Tunnel ID associated with this path";
                        }
    
                        leaf pathid {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Path id of this path";
                        }
    
                        leaf backup-pathid {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Path id of this path's backup";
                        }
    
                        leaf ref-cnt-of-backup {
                          type uint32;
                          description
                            "For backup paths, the number of active paths
    protected by the backup path";
                        }
    
                        leaf number-of-extended-communities {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Number of extended communities associated with
    this path";
                        }
    
                        leaf mvpn-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "MVPN attribute present";
                        }
    
                        leaf path-rt-present {
                          type boolean;
                          description
                            "Path RT present";
                        }
    
                        leaf vrf-import-rt-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "VRFIMPORTRTPresent";
                        }
    
                        leaf source-asrt-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "SOURCEASRTPresent";
                        }
    
                        leaf source-rd-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "SOURCERDPresent";
                        }
    
                        leaf segmented-nexthop-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "Segmented NH attributes present for this path";
                        }
    
                        leaf number-of-nnh {
                          type uint32;
                          description
                            "Number of Next Next Hops";
                        }
    
                        leaf next-hop-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "NHID associated with this path";
                        }
    
                        leaf next-hop-id-refcount {
                          type uint32;
                          description
                            "NHID references";
                        }
    
                        leaf ospf-area-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "OSPF area associated with the path";
                        }
    
                        leaf has-labelstk {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "Path has a label stack";
                        }
    
                        leaf num-labels {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Number of labels in stack";
                        }
    
                        leaf binding-label {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "binding Label for this path";
                        }
    
                        leaf nhid-feid {
                          type uint64;
                          description
                            "Fib nhid encap id";
                        }
    
                        leaf mpls-feid {
                          type uint64;
                          description
                            "Fib mpls encap id";
                        }
    
                        leaf has-vxlan-network-id {
                          type boolean;
                          description
                            "VXLAN Network Identifier exists for this path";
                        }
    
                        leaf vxlan-network-id {
                          type uint32;
                          description
                            "VXLAN Network Identifier for this path";
                        }
    
                        leaf has-xcid {
                          type boolean;
                          description
                            "L2 Cross Connect ID exists for this path";
                        }
    
                        leaf xcid {
                          type uint32;
                          description
                            "L2 Cross Connect ID for this path";
                        }
    
                        leaf has-span-diag-interface {
                          type boolean;
                          description
                            "SPAN Diagnostics Interface exists for this path";
                        }
    
                        leaf span-diag-interface {
                          type xr:Interface-name;
                          description
                            "SPAN Diagnostics Interface for this path";
                        }
    
                        leaf has-subscriber-parent-interface {
                          type boolean;
                          description
                            "Subscriber Parent Interface exists for this
    path";
                        }
    
                        leaf subscriber-parent-interface {
                          type xr:Interface-name;
                          description
                            "Subscriber Parent Interface for this path";
                        }
    
                        leaf interface-index-present {
                          type boolean;
                          description
                            "Flag to indicate if interface index attribute
    is present for this path";
                        }
    
                        leaf interface-index-attribute {
                          type uint32;
                          description
                            "Interface Index attribute";
                        }
    
                        leaf iid-present {
                          type boolean;
                          description
                            "Internal ID present";
                        }
    
                        leaf iid {
                          type Ipv4-rib-edm-addr;
                          description
                            "Internal ID attribute";
                        }
    
                        leaf has-l2-info {
                          type boolean;
                          description
                            "L2 Info present for this path";
                        }
    
                        list remote-backup-addr {
                          max-elements 2;
                          description
                            "Remote backup node address";
                          leaf entry {
                            xr:event-telemetry "Subscribe Telemetry Event";
                            type Ipv4-rib-edm-addr;
                            description
                              "Remote backup node address";
                          }
                        }  // list remote-backup-addr
    
                        list labelstk {
                          description
                            "Outgoing label stack for this path";
                          leaf entry {
                            xr:event-telemetry "Subscribe Telemetry Event";
                            type uint32;
                            description
                              "Outgoing label stack for this path";
                          }
                        }  // list labelstk
    
                        list next-next-hop {
                          description
                            "List of Next Next Hops";
                          leaf type {
                            type Rib-edm-nnh;
                            description "type";
                          }
    
                          leaf unknownval {
                            when
                              "../type = 'unknown'" {
                              description
                                "../type = 'Unknown'";
                            }
                            type uint32;
                            description
                              "Unknown Value";
                          }
    
                          leaf address {
                            when
                              "../type = 'ipv4-address'" {
                              description
                                "../type = 'IPv4Address'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }
    
                          leaf interface-index {
                            when
                              "../type = 'if-index'" {
                              description
                                "../type = 'IfIndex'";
                            }
                            type uint32;
                            description
                              "Interface Index";
                          }
                        }  // list next-next-hop
                      }  // list ipv4-rib-edm-path
                    }  // container route-path
    
                    leaf prefix {
                      type Ipv4-rib-edm-addr;
                      description "Route prefix";
                    }
    
                    leaf prefix-length-xr {
                      type uint8;
                      description
                        "Length of prefix";
                    }
    
                    leaf route-version {
                      type uint32;
                      description
                        "Route version, incremented by one on each active
    route change";
                    }
    
                    leaf protocol-id {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Protocol advertising the route";
                    }
    
                    leaf protocol-name {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type string;
                      description
                        " Name of Protocol";
                    }
    
                    leaf instance {
                      type string;
                      description
                        "Instance name";
                    }
    
                    leaf client-id {
                      type uint32;
                      description
                        "Client adding the route to RIB";
                    }
    
                    leaf route-type {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint16;
                      description
                        "Type of route installed in RIB";
                    }
    
                    leaf priority {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Route priority";
                    }
    
                    leaf svd-type {
                      type uint8;
                      description
                        "SVD Type of route";
                    }
    
                    leaf l2-route-type {
                      type uint8;
                      description
                        "Type of route associated with L2 Service";
                    }
    
                    leaf flags {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description "Route flags";
                    }
    
                    leaf extended-flags {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint64;
                      description
                        "Extended Route flags";
                    }
    
                    leaf tag {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Opaque proto specific info";
                    }
    
                    leaf distance {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Distance of the route";
                    }
    
                    leaf diversion-distance {
                      type uint32;
                      description
                        "Diversion distance of the route";
                    }
    
                    leaf metric {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description "Route metric";
                    }
    
                    leaf paths-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Number of paths";
                    }
    
                    leaf attribute-identity {
                      type uint32;
                      description
                        "BGP Attribute ID";
                    }
    
                    leaf traffic-index {
                      type uint8;
                      description
                        "BGP Traffic Index";
                    }
    
                    leaf route-precedence {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "IP precedence for this route";
                    }
    
                    leaf qos-group {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Route qos group";
                    }
    
                    leaf flow-tag {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Flow tag for this route";
                    }
    
                    leaf fwd-class {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Forward Class";
                    }
    
                    leaf pic-count {
                      type uint8;
                      description
                        "Number of pic paths in this route";
                    }
    
                    leaf active {
                      type boolean;
                      description
                        "Is the route active or backup";
                    }
    
                    leaf diversion {
                      type boolean;
                      description
                        "Route has a diversion path";
                    }
    
                    leaf diversion-proto-name {
                      type string;
                      description
                        "Diversion route protocol name";
                    }
    
                    leaf route-age {
                      type uint32;
                      units "second";
                      description
                        "Age of route (seconds)";
                    }
    
                    leaf route-label {
                      type uint32;
                      description
                        "Local label of the route";
                    }
    
                    leaf version {
                      type uint32;
                      description
                        "Route Version";
                    }
    
                    leaf tbl-version {
                      type uint64;
                      description
                        "Table Version";
                    }
    
                    leaf route-modify-time {
                      type uint64;
                      units "nanosecond";
                      description
                        "Route modification time(nanoseconds)";
                    }
    
                    leaf prefix-feid {
                      type uint64;
                      description
                        "Fib per-prefix encap id";
                    }
    
                    leaf number-of-algorithm-labels {
                      type uint16;
                      description
                        "Number of Algorithm Labels associated with this
    prefix";
                    }
    
                    list algorithm-label {
                      description
                        "List of Algorithm Labels associated with this
    Prefix";
                      leaf algorithm-id {
                        type uint8;
                        description
                          "Algorithm Identifier";
                      }
    
                      leaf label {
                        type uint32;
                        description
                          "Local label";
                      }
    
                      leaf metric {
                        type uint32;
                        description
                          "Route Metric associated with Algorithm
    Identifier";
                      }
                    }  // list algorithm-label
                  }  // list itf-route
                }  // list rib-table-itf-hndl
              }  // container rib-table-itf-hndls
    
              container information {
                description
                  "Table related Information";
                leaf tableid {
                  type uint32;
                  description "Table id";
                }
    
                leaf afi {
                  type uint32;
                  description "Address Family";
                }
    
                leaf safi {
                  type uint32;
                  description
                    "sub Address Family";
                }
    
                leaf vrf-name {
                  type string;
                  description
                    "VRF Name of the table";
                }
    
                leaf table-name {
                  type string;
                  description
                    "Name of the table";
                }
    
                leaf version {
                  type uint64;
                  description "Table version";
                }
    
                leaf conf-prefix-limit {
                  type uint32;
                  description
                    "Configured prefix limit";
                }
    
                leaf current-prefix-count {
                  type uint32;
                  description
                    "Num prefixes in table";
                }
    
                leaf num-svdlcl-prefix {
                  type uint32;
                  description
                    "Num SVD local prefixes";
                }
    
                leaf num-svdrem-prefix {
                  type uint32;
                  description
                    "Num SVD remote prefixes";
                }
    
                leaf table-version {
                  type uint64;
                  description
                    "Version no. of the table";
                }
    
                leaf prefix-limit-notified {
                  type boolean;
                  description
                    "Prefix limit state indicator";
                }
    
                leaf fwd-referenced {
                  type boolean;
                  description
                    "Table in fwd reference state?";
                }
    
                leaf deleted {
                  type boolean;
                  description "Table deleted?";
                }
    
                leaf initial-converge {
                  type boolean;
                  description
                    "Table has reached convergence";
                }
              }  // container information
    
              container rib-nexthop-prefixes {
                description
                  "RIB table nexthop client table";
                list rib-nexthop-prefix {
                  description
                    "Route address, Prefix length";
                  container rib-nexthop-routes {
                    description
                      "Nexthop route table";
                    list rib-nexthop-route {
                      description
                        "Route information for a specific
    table/interface";
                      leaf exact-match {
                        type boolean;
                        description
                          "Exact Match";
                      }
    
                      leaf allow-default {
                        type boolean;
                        description
                          "Allow Default";
                      }
    
                      leaf recurse {
                        type boolean;
                        description "Recurse";
                      }
    
                      leaf cross-table {
                        type boolean;
                        description
                          "Cross table nextHop";
                      }
    
                      leaf pack-sfs {
                        type boolean;
                        description
                          "Pack SFS paths for Multicast";
                      }
    
                      leaf pack-backup-paths {
                        type boolean;
                        description
                          "Pack backup paths";
                      }
    
                      leaf backup-route {
                        type boolean;
                        description
                          "Backup route notifications";
                      }
    
                      leaf best-metric {
                        type boolean;
                        description
                          "Return lowest metric";
                      }
    
                      container clients {
                        description
                          "Client(s) of the address";
                        list rib-edm-nh-client {
                          description
                            "Next client";
                          leaf id {
                            type uint32;
                            description
                              "Client id";
                          }
    
                          leaf ref-count {
                            type uint32;
                            description
                              "The number NH reference this client";
                          }
    
                          leaf nh-create-age {
                            type uint32;
                            description
                              "How long has client has been created";
                          }
    
                          leaf nh-create-time {
                            type uint64;
                            description
                              "Client creation time";
                          }
    
                          leaf nh-read-age {
                            type uint32;
                            description
                              "How long ago client read this notification";
                          }
    
                          leaf nh-read-time {
                            type uint64;
                            description
                              "Client notification read time";
                          }
    
                          leaf pack-mvpn {
                            type boolean;
                            description
                              "Pack MVPN";
                          }
    
                          leaf pack-path-rt {
                            type boolean;
                            description
                              "Pack path RT";
                          }
    
                          leaf pack-vrf-import-rt {
                            type boolean;
                            description
                              "Pack VRF import RT";
                          }
    
                          leaf pack-source-as-rt {
                            type boolean;
                            description
                              "Pack source AS RT";
                          }
    
                          leaf pack-source-rd {
                            type boolean;
                            description
                              "Pack source RD";
                          }
    
                          leaf pack-mldp-root {
                            type boolean;
                            description
                              "Pack MLDP root";
                          }
    
                          leaf pack-seg-nh {
                            type boolean;
                            description
                              "Pack seg NH";
                          }
    
                          leaf notify-reregister {
                            type boolean;
                            description
                              "Notify Reregister";
                          }
                        }  // list rib-edm-nh-client
                      }  // container clients
    
                      container resolved-route {
                        description
                          "Route resolved this nexthop";
                        container srv6-info {
                          description
                            "SRv6 related information";
                          container srv6-endpoint-behavior {
                            description
                              "SRv6 Endpoint behavior/type";
                            leaf type {
                              type Mgmt-srv6-endpoint;
                              description
                                "Behavior type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-endpoint-behavior
    
                          container srv6-format {
                            description
                              "SRv6 Format";
                            leaf type {
                              type Mgmt-srv6-sid-fmt;
                              description
                                "Format type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Format description";
                            }
                          }  // container srv6-format
    
                          leaf is-srv6-endpoint {
                            type boolean;
                            description
                              "Route is an SRv6 Endpoint (local SID)";
                          }
    
                          leaf is-srv6-locator {
                            type boolean;
                            description
                              "Route corresponds to an SRv6 remote locator";
                          }
    
                          leaf srv6-locator-algo {
                            type uint8;
                            description
                              "SRv6 Algo corresponding to SRv6 remote locator";
                          }
                        }  // container srv6-info
    
                        container route-path {
                          description
                            "Path(s) of the route";
                          list ipv4-rib-edm-path {
                            description
                              "Next path";
                            container l2-info {
                              description
                                "L2 Info for this path";
                              leaf xcid {
                                type uint32;
                                description
                                  "L2 Cross Connect ID for this path";
                              }
    
                              leaf ac-interface {
                                type xr:Interface-name;
                                description
                                  "L2 AC Interface";
                              }
                            }  // container l2-info
    
                            container srv6-info {
                              description
                                "SRv6 related information";
                              container srv6-carrier-format {
                                description
                                  "SRv6 Carrier Format";
                                leaf type {
                                  type Mgmt-srv6-sid-fmt;
                                  description
                                    "Format type";
                                }
    
                                leaf description {
                                  type string;
                                  description
                                    "Format description";
                                }
                              }  // container srv6-carrier-format
    
                              container srv6-headend-behavior {
                                description
                                  "SRv6 headend behavior/type info";
                                leaf type {
                                  type Mgmt-srv6-headend;
                                  description
                                    "Behavior type";
                                }
    
                                leaf description {
                                  type string;
                                  description
                                    "Behavior description";
                                }
                              }  // container srv6-headend-behavior
    
                              container via-srv6-sid {
                                description
                                  "Via-SRv6-SID value";
                                leaf sid {
                                  type inet:ipv6-address;
                                  description
                                    "Via-SRv6-SID value";
                                }
    
                                leaf resolution-length {
                                  type uint8;
                                  description
                                    "FIB Resolution length";
                                }
                              }  // container via-srv6-sid
    
                              leaf number-of-srv6-carriers {
                                type uint8;
                                description
                                  "Number of SRv6 Carriers";
                              }
    
                              leaf has-srv6-headend-behavior {
                                type boolean;
                                description
                                  "Path has some SRv6 head-end behavior associated";
                              }
    
                              leaf has-via-srv6-sid {
                                type boolean;
                                description
                                  "Via-SRv6-SID is present";
                              }
    
                              list srv6-carrier {
                                description
                                  "List of SRv6 Carriers with one or more SIDs";
                                leaf sid {
                                  type inet:ipv6-address;
                                  description
                                    "SID value";
                                }
                              }  // list srv6-carrier
                            }  // container srv6-info
    
                            leaf address {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type Ipv4-rib-edm-addr;
                              description
                                "Nexthop";
                            }
    
                            leaf information-source {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type Ipv4-rib-edm-addr;
                              description
                                "Infosource";
                            }
    
                            leaf v6-nexthop {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type inet:ipv6-address;
                              description
                                "IPv6 nexthop for v4 over v6";
                            }
    
                            leaf v6-information-source {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type inet:ipv6-address;
                              description
                                "V6 Infosource";
                            }
    
                            leaf interface-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type xr:Interface-name;
                              description
                                "Interface handle for the path's nexthop";
                            }
    
                            leaf metric {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Metrics";
                            }
    
                            leaf load-metric {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Load Metrics";
                            }
    
                            leaf flags64 {
                              type uint64;
                              description
                                "Flags extended to 64 bits";
                            }
    
                            leaf flags {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint16;
                              description
                                "Flags";
                            }
    
                            leaf private-flags {
                              type uint16;
                              description
                                "Private Flags, used internally by RIB";
                            }
    
                            leaf minimum-recurse-length {
                              type uint8;
                              description
                                "Minimum netmask length of recursive resolving
    route";
                            }
    
                            leaf looped {
                              type boolean;
                              description
                                "Looping path";
                            }
    
                            leaf next-hop-table-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "The table to which the next hop belongs";
                            }
    
                            leaf next-hop-vrf-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "VRF Name of the nh table";
                            }
    
                            leaf next-hop-table-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "NH table name";
                            }
    
                            leaf next-hop-afi {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NH afi";
                            }
    
                            leaf next-hop-safi {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NH safi";
                            }
    
                            leaf route-label {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Label associated with this path";
                            }
    
                            leaf tunnel-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Tunnel ID associated with this path";
                            }
    
                            leaf pathid {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Path id of this path";
                            }
    
                            leaf backup-pathid {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Path id of this path's backup";
                            }
    
                            leaf ref-cnt-of-backup {
                              type uint32;
                              description
                                "For backup paths, the number of active paths
    protected by the backup path";
                            }
    
                            leaf number-of-extended-communities {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Number of extended communities associated with
    this path";
                            }
    
                            leaf mvpn-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "MVPN attribute present";
                            }
    
                            leaf path-rt-present {
                              type boolean;
                              description
                                "Path RT present";
                            }
    
                            leaf vrf-import-rt-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "VRFIMPORTRTPresent";
                            }
    
                            leaf source-asrt-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "SOURCEASRTPresent";
                            }
    
                            leaf source-rd-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "SOURCERDPresent";
                            }
    
                            leaf segmented-nexthop-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "Segmented NH attributes present for this path";
                            }
    
                            leaf number-of-nnh {
                              type uint32;
                              description
                                "Number of Next Next Hops";
                            }
    
                            leaf next-hop-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NHID associated with this path";
                            }
    
                            leaf next-hop-id-refcount {
                              type uint32;
                              description
                                "NHID references";
                            }
    
                            leaf ospf-area-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "OSPF area associated with the path";
                            }
    
                            leaf has-labelstk {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "Path has a label stack";
                            }
    
                            leaf num-labels {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint8;
                              description
                                "Number of labels in stack";
                            }
    
                            leaf binding-label {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "binding Label for this path";
                            }
    
                            leaf nhid-feid {
                              type uint64;
                              description
                                "Fib nhid encap id";
                            }
    
                            leaf mpls-feid {
                              type uint64;
                              description
                                "Fib mpls encap id";
                            }
    
                            leaf has-vxlan-network-id {
                              type boolean;
                              description
                                "VXLAN Network Identifier exists for this path";
                            }
    
                            leaf vxlan-network-id {
                              type uint32;
                              description
                                "VXLAN Network Identifier for this path";
                            }
    
                            leaf has-xcid {
                              type boolean;
                              description
                                "L2 Cross Connect ID exists for this path";
                            }
    
                            leaf xcid {
                              type uint32;
                              description
                                "L2 Cross Connect ID for this path";
                            }
    
                            leaf has-span-diag-interface {
                              type boolean;
                              description
                                "SPAN Diagnostics Interface exists for this path";
                            }
    
                            leaf span-diag-interface {
                              type xr:Interface-name;
                              description
                                "SPAN Diagnostics Interface for this path";
                            }
    
                            leaf has-subscriber-parent-interface {
                              type boolean;
                              description
                                "Subscriber Parent Interface exists for this
    path";
                            }
    
                            leaf subscriber-parent-interface {
                              type xr:Interface-name;
                              description
                                "Subscriber Parent Interface for this path";
                            }
    
                            leaf interface-index-present {
                              type boolean;
                              description
                                "Flag to indicate if interface index attribute
    is present for this path";
                            }
    
                            leaf interface-index-attribute {
                              type uint32;
                              description
                                "Interface Index attribute";
                            }
    
                            leaf iid-present {
                              type boolean;
                              description
                                "Internal ID present";
                            }
    
                            leaf iid {
                              type Ipv4-rib-edm-addr;
                              description
                                "Internal ID attribute";
                            }
    
                            leaf has-l2-info {
                              type boolean;
                              description
                                "L2 Info present for this path";
                            }
    
                            list remote-backup-addr {
                              max-elements 2;
                              description
                                "Remote backup node address";
                              leaf entry {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type Ipv4-rib-edm-addr;
                                description
                                  "Remote backup node address";
                              }
                            }  // list remote-backup-addr
    
                            list labelstk {
                              description
                                "Outgoing label stack for this path";
                              leaf entry {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Outgoing label stack for this path";
                              }
                            }  // list labelstk
    
                            list next-next-hop {
                              description
                                "List of Next Next Hops";
                              leaf type {
                                type Rib-edm-nnh;
                                description
                                  "type";
                              }
    
                              leaf unknownval {
                                when
                                  "../type = 'unknown'" {
                                  description
                                    "../type = 'Unknown'";
                                }
                                type uint32;
                                description
                                  "Unknown Value";
                              }
    
                              leaf address {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../type = 'IPv4Address'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }
    
                              leaf interface-index {
                                when
                                  "../type = 'if-index'" {
                                  description
                                    "../type = 'IfIndex'";
                                }
                                type uint32;
                                description
                                  "Interface Index";
                              }
                            }  // list next-next-hop
                          }  // list ipv4-rib-edm-path
                        }  // container route-path
    
                        leaf prefix {
                          type Ipv4-rib-edm-addr;
                          description
                            "Route prefix";
                        }
    
                        leaf prefix-length-xr {
                          type uint8;
                          description
                            "Length of prefix";
                        }
    
                        leaf route-version {
                          type uint32;
                          description
                            "Route version, incremented by one on each active
    route change";
                        }
    
                        leaf protocol-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Protocol advertising the route";
                        }
    
                        leaf protocol-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            " Name of Protocol";
                        }
    
                        leaf instance {
                          type string;
                          description
                            "Instance name";
                        }
    
                        leaf client-id {
                          type uint32;
                          description
                            "Client adding the route to RIB";
                        }
    
                        leaf route-type {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint16;
                          description
                            "Type of route installed in RIB";
                        }
    
                        leaf priority {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Route priority";
                        }
    
                        leaf svd-type {
                          type uint8;
                          description
                            "SVD Type of route";
                        }
    
                        leaf l2-route-type {
                          type uint8;
                          description
                            "Type of route associated with L2 Service";
                        }
    
                        leaf flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Route flags";
                        }
    
                        leaf extended-flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint64;
                          description
                            "Extended Route flags";
                        }
    
                        leaf tag {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Opaque proto specific info";
                        }
    
                        leaf distance {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Distance of the route";
                        }
    
                        leaf diversion-distance {
                          type uint32;
                          description
                            "Diversion distance of the route";
                        }
    
                        leaf metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Route metric";
                        }
    
                        leaf paths-count {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Number of paths";
                        }
    
                        leaf attribute-identity {
                          type uint32;
                          description
                            "BGP Attribute ID";
                        }
    
                        leaf traffic-index {
                          type uint8;
                          description
                            "BGP Traffic Index";
                        }
    
                        leaf route-precedence {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "IP precedence for this route";
                        }
    
                        leaf qos-group {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Route qos group";
                        }
    
                        leaf flow-tag {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Flow tag for this route";
                        }
    
                        leaf fwd-class {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Forward Class";
                        }
    
                        leaf pic-count {
                          type uint8;
                          description
                            "Number of pic paths in this route";
                        }
    
                        leaf active {
                          type boolean;
                          description
                            "Is the route active or backup";
                        }
    
                        leaf diversion {
                          type boolean;
                          description
                            "Route has a diversion path";
                        }
    
                        leaf diversion-proto-name {
                          type string;
                          description
                            "Diversion route protocol name";
                        }
    
                        leaf route-age {
                          type uint32;
                          units "second";
                          description
                            "Age of route (seconds)";
                        }
    
                        leaf route-label {
                          type uint32;
                          description
                            "Local label of the route";
                        }
    
                        leaf version {
                          type uint32;
                          description
                            "Route Version";
                        }
    
                        leaf tbl-version {
                          type uint64;
                          description
                            "Table Version";
                        }
    
                        leaf route-modify-time {
                          type uint64;
                          units "nanosecond";
                          description
                            "Route modification time(nanoseconds)";
                        }
    
                        leaf prefix-feid {
                          type uint64;
                          description
                            "Fib per-prefix encap id";
                        }
    
                        leaf number-of-algorithm-labels {
                          type uint16;
                          description
                            "Number of Algorithm Labels associated with this
    prefix";
                        }
    
                        list algorithm-label {
                          description
                            "List of Algorithm Labels associated with this
    Prefix";
                          leaf algorithm-id {
                            type uint8;
                            description
                              "Algorithm Identifier";
                          }
    
                          leaf label {
                            type uint32;
                            description
                              "Local label";
                          }
    
                          leaf metric {
                            type uint32;
                            description
                              "Route Metric associated with Algorithm
    Identifier";
                          }
                        }  // list algorithm-label
                      }  // container resolved-route
    
                      leaf prefix {
                        type Ipv4-rib-edm-addr;
                        description
                          "Route prefix";
                      }
    
                      leaf prefix-len {
                        type uint32;
                        description
                          "Length of prefix";
                      }
    
                      leaf dest-addr {
                        type Ipv4-rib-edm-addr;
                        description
                          "Destination address";
                      }
    
                      leaf dest-intf {
                        type uint32;
                        description
                          "Destination interface";
                      }
    
                      leaf dest-tableid {
                        type uint32;
                        description
                          "Destination tableid";
                      }
    
                      leaf dest-metric {
                        type uint32;
                        description
                          "Destination metric";
                      }
    
                      leaf dest-vrf-name {
                        type string;
                        description
                          "VRF Name of the nh table";
                      }
    
                      leaf damped {
                        type boolean;
                        description
                          "Nexthop being damped?";
                      }
    
                      leaf exact-match-xr {
                        type boolean;
                        description
                          "Exact match";
                      }
    
                      leaf allow-default-xr {
                        type boolean;
                        description
                          "Allow default flag";
                      }
    
                      leaf recurse-xr {
                        type boolean;
                        description
                          "Allow recurse flag";
                      }
    
                      leaf xtable {
                        type boolean;
                        description
                          "Cross table nexthop";
                      }
    
                      leaf pack-sf-xr {
                        type boolean;
                        description
                          "Pack SFS paths for multicast";
                      }
    
                      leaf pack-backup {
                        type boolean;
                        description
                          "Pack backup paths";
                      }
    
                      leaf backup-route-xr {
                        type boolean;
                        description
                          "Backup route notifications";
                      }
    
                      leaf best-metric-xr {
                        type boolean;
                        description
                          "Return lowest metric for dest. metric";
                      }
    
                      leaf unres-nh-tree {
                        type boolean;
                        description
                          "Context about which tree the server should walk";
                      }
    
                      leaf flags {
                        type uint16;
                        description
                          "nh_entry flags";
                      }
    
                      leaf dest-path-count {
                        type uint32;
                        description
                          "Number of destination paths";
                      }
    
                      leaf accrued-penalty {
                        type uint16;
                        description
                          "Damped accured penalty";
                      }
    
                      leaf expiration-age {
                        type uint32;
                        description
                          "How soon the nexthop is undamped";
                      }
    
                      leaf expiration-time {
                        type uint64;
                        description
                          "Time where the first is undamped";
                      }
    
                      leaf min-damped-threshold {
                        type uint32;
                        description
                          "Minimum damped threshold";
                      }
    
                      leaf max-damped-penalty {
                        type uint32;
                        description
                          "Maximum damped threshold";
                      }
    
                      leaf decay-rate {
                        type uint32;
                        description
                          "Damped decay rate";
                      }
    
                      leaf version {
                        type uint32;
                        description
                          "Event version";
                      }
    
                      leaf last-event-age {
                        type uint32;
                        description
                          "How long since last event occured";
                      }
    
                      leaf last-event-time {
                        type uint64;
                        description
                          "Time at which last event occured";
                      }
    
                      list dest-path {
                        description
                          "Path(s) of the route";
                        leaf interface {
                          type uint32;
                          description
                            "interface";
                        }
    
                        leaf address {
                          type Ipv4-rib-edm-addr;
                          description "Address";
                        }
    
                        leaf tableid {
                          type uint32;
                          description "tableid";
                        }
    
                        leaf vrf-name {
                          type string;
                          description
                            "VRF Name of the nh table";
                        }
                      }  // list dest-path
                    }  // list rib-nexthop-route
                  }  // container rib-nexthop-routes
    
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description "Route Address ";
                  }
    
                  leaf prefix-length {
                    type xr:Ipv4-prefix-length;
                    description "Prefix Length ";
                  }
    
                  leaf unresolved-nh-tree {
                    type boolean;
                    description
                      "Unresolved Nexthop Tree";
                  }
                }  // list rib-nexthop-prefix
              }  // container rib-nexthop-prefixes
    
              container nexthops-summary {
                description "Nexthops summary";
                leaf num-resolved-nh {
                  type uint32;
                  description
                    "Number of resolved nexthop";
                }
    
                leaf num-unresolved-nh {
                  type uint32;
                  description
                    "Number of unresolved nexthop";
                }
              }  // container nexthops-summary
    
              leaf tableid {
                type xr:Hex-integer;
                description "Table ID";
              }
            }  // list rib-table-id
          }  // container rib-table-ids
    
          container rib-rpfs {
            description "Route prefix table";
            list rib-rpf {
              key "table-id";
              description "Table Id";
              container rib-rpf-list-routes {
                description
                  "rpf list table route";
                list rib-rpf-list-route {
                  description
                    "Last route prefix and prefix length";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description "Route Address ";
                  }
    
                  leaf prefix-length {
                    type xr:Ipv4-prefix-length;
                    description "Prefix Length ";
                  }
    
                  leaf label {
                    type uint32;
                    description "label";
                  }
    
                  leaf flags {
                    type uint32;
                    description "flags";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf sent-to-fib {
                    type boolean;
                    description "sent to fib";
                  }
    
                  list nbr {
                    description "nbr";
                    leaf afi {
                      type uint8;
                      description "afi";
                    }
    
                    leaf ip-address {
                      type Ipv4-rib-edm-addr;
                      description "ip address";
                    }
                  }  // list nbr
                }  // list rib-rpf-list-route
              }  // container rib-rpf-list-routes
    
              container rib-rpf-list-summary-head-counts {
                description
                  "rpf list table summary";
                list rib-rpf-list-summary-head-count {
                  key "rpf-head-count";
                  description "RPF Head count";
                  leaf rpf-head-count {
                    type Rpf-head-count-range;
                    description "RPF Head count";
                  }
    
                  leaf label {
                    type uint32;
                    description "label";
                  }
    
                  leaf flags {
                    type uint32;
                    description "flags";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf sent-to-fib {
                    type boolean;
                    description "sent to fib";
                  }
    
                  list nbr {
                    description "nbr";
                    leaf afi {
                      type uint8;
                      description "afi";
                    }
    
                    leaf ip-address {
                      type Ipv4-rib-edm-addr;
                      description "ip address";
                    }
                  }  // list nbr
                }  // list rib-rpf-list-summary-head-count
              }  // container rib-rpf-list-summary-head-counts
    
              leaf table-id {
                type Table-id-range-ipv4;
                description "Table ID";
              }
            }  // list rib-rpf
          }  // container rib-rpfs
    
          container rib-nh-id-summaries {
            description "NHIds table";
            list rib-nh-id-summary {
              key "table-id";
              description "Table Id";
              container rib-nh-ids {
                description "nhids summary";
                list rib-nh-id {
                  key "nh-id-entry-count";
                  description "NH Id";
                  leaf nh-id-entry-count {
                    type Nhid-entry-count-range;
                    description
                      "NH Id entry count";
                  }
    
                  leaf nhid {
                    type uint32;
                    description "nhid";
                  }
    
                  leaf feid {
                    type uint64;
                    description "feid";
                  }
    
                  leaf nh-addr {
                    type Ipv4-rib-edm-addr;
                    description "nh addr";
                  }
    
                  leaf ifindex {
                    type xr:Interface-name;
                    description "ifindex";
                  }
    
                  leaf chkpt-obj-id {
                    type uint32;
                    description "chkpt obj id";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf feature-type {
                    type uint8;
                    description "feature type";
                  }
                }  // list rib-nh-id
              }  // container rib-nh-ids
    
              leaf table-id {
                type Table-id-range-ipv4;
                description "Table Id";
              }
            }  // list rib-nh-id-summary
          }  // container rib-nh-id-summaries
    
          container rib-stats {
            description "Statistics summary";
            container rib-stats-summary {
              description "Summary";
              container batch-stats {
                description "batch stats";
                leaf total-msg-rx {
                  type uint32;
                  description "total msg rx";
                }
    
                leaf route-op-arg-rx {
                  type uint32;
                  description "route op arg rx";
                }
    
                leaf attribute-arg-rx {
                  type uint32;
                  description "attribute arg rx";
                }
    
                leaf complete-arg-rx {
                  type uint32;
                  description "complete arg rx";
                }
    
                leaf converge-arg-rx {
                  type uint32;
                  description "converge arg rx";
                }
    
                leaf opaque-arg-rx {
                  type uint32;
                  description "opaque arg rx";
                }
    
                leaf total-fwd-ref {
                  type uint32;
                  description "total fwd ref";
                }
    
                leaf invalid-client-id-error {
                  type uint32;
                  description
                    "invalid client id error";
                }
    
                leaf mem-alloc-error {
                  type uint32;
                  description "mem alloc error";
                }
    
                leaf client-lookup-error {
                  type uint32;
                  description
                    "client lookup error";
                }
    
                leaf db-lookup-error {
                  type uint32;
                  description "db lookup error";
                }
    
                leaf proto-lookup-error {
                  type uint32;
                  description
                    "proto lookup error";
                }
    
                leaf client-proto-lookup-error {
                  type uint32;
                  description
                    "client proto lookup error";
                }
    
                leaf table-missing-error {
                  type uint32;
                  description
                    "table missing error";
                }
    
                leaf unknown-arg {
                  type uint32;
                  description "unknown arg";
                }
    
                leaf success {
                  type uint32;
                  description "success";
                }
    
                leaf last-result {
                  type uint32;
                  description "last result";
                }
    
                leaf last-operation {
                  type uint32;
                  description "last operation";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-msg-rx-time {
                  type uint64;
                  description "last msg rx time";
                }
              }  // container batch-stats
    
              container lwm-stats {
                description "lwm stats";
                leaf total-lwm {
                  type uint32;
                  description "total lwm";
                }
    
                leaf route-add {
                  type uint32;
                  description "route add";
                }
    
                leaf route-delete {
                  type uint32;
                  description "route delete";
                }
    
                leaf purge-protocol {
                  type uint32;
                  description "purge protocol";
                }
    
                leaf purge-client {
                  type uint32;
                  description "purge client";
                }
    
                leaf protocol-register {
                  type uint32;
                  description
                    "protocol register";
                }
    
                leaf protocol-unregister {
                  type uint32;
                  description
                    "protocol unregister";
                }
    
                leaf protocol-modify {
                  type uint32;
                  description "protocol modify";
                }
    
                leaf redist-proto {
                  type uint32;
                  description "redist proto";
                }
    
                leaf unreg-redist-proto {
                  type uint32;
                  description
                    "unreg redist proto";
                }
    
                leaf redist-reset {
                  type uint32;
                  description "redist reset";
                }
    
                leaf update-complete {
                  type uint32;
                  description "update complete";
                }
    
                leaf advertisement {
                  type uint32;
                  description "advertisement";
                }
    
                leaf unreg-advertisement {
                  type uint32;
                  description
                    "unreg advertisement";
                }
    
                leaf next-hop-register {
                  type uint32;
                  description
                    "next hop register";
                }
    
                leaf next-hop-unregister {
                  type uint32;
                  description
                    "next hop unregister";
                }
    
                leaf bind-data {
                  type uint32;
                  description "bind data";
                }
    
                leaf succcess {
                  type uint32;
                  description "succcess";
                }
    
                leaf route-lookup {
                  type uint32;
                  description "route lookup";
                }
    
                leaf best-local-addr {
                  type uint32;
                  description "best local addr";
                }
    
                leaf is-connected {
                  type uint32;
                  description "is connected";
                }
    
                leaf first-hop {
                  type uint32;
                  description "first hop";
                }
    
                leaf find-proto {
                  type uint32;
                  description "find proto";
                }
    
                leaf free-all-srv6-sid {
                  type uint32;
                  description
                    "free all srv6 sid";
                }
    
                leaf other {
                  type uint32;
                  description "other";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-operation {
                  type uint32;
                  description "last operation";
                }
    
                leaf last-oper-result {
                  type boolean;
                  description "last oper result";
                }
    
                leaf last-lwm-time {
                  type uint64;
                  description "last lwm time";
                }
              }  // container lwm-stats
    
              container nh-batch-stats {
                description "nh batch stats";
                leaf total-nh-batch-requests {
                  type uint32;
                  description
                    "total nh batch requests";
                }
    
                leaf total-nh-operations {
                  type uint32;
                  description
                    "total nh operations";
                }
    
                leaf batch-init {
                  type uint32;
                  description "batch init";
                }
    
                leaf batch-register {
                  type uint32;
                  description "batch register";
                }
    
                leaf batch-unregister {
                  type uint32;
                  description "batch unregister";
                }
    
                leaf register-complete {
                  type uint32;
                  description
                    "register complete";
                }
    
                leaf sync-register {
                  type uint32;
                  description "sync register";
                }
    
                leaf batch-finish {
                  type uint32;
                  description "batch finish";
                }
    
                leaf batch-null {
                  type uint32;
                  description "batch null";
                }
    
                leaf success {
                  type uint32;
                  description "success";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-nh-operation {
                  type uint32;
                  description
                    "last nh operation";
                }
    
                leaf last-result {
                  type boolean;
                  description "last result";
                }
    
                leaf last-nh-time {
                  type uint64;
                  description "last nh time";
                }
              }  // container nh-batch-stats
    
              container grid-stats {
                description "grid stats";
                leaf num-in-queue {
                  type uint32;
                  description "num in queue";
                }
    
                leaf num-enqueue {
                  type uint32;
                  description "num enqueue";
                }
    
                leaf num-dequeue {
                  type uint32;
                  description "num dequeue";
                }
    
                leaf num-enqueue-del-skipped {
                  type uint32;
                  description
                    "num enqueue del skipped";
                }
    
                leaf num-requeue {
                  type uint32;
                  description "num requeue";
                }
              }  // container grid-stats
            }  // container rib-stats-summary
          }  // container rib-stats
    
          container rib-max-depth {
            description
              "Information of maximum recursion depth in RIB";
            leaf current {
              type uint32;
              description
                "Current maximum recursion depth";
            }
    
            leaf configured {
              type uint32;
              description
                "Configured maximum recursion depth";
            }
          }  // container rib-max-depth
    
          container rib-clients {
            description "Client";
            list rib-client {
              key "clientid";
              description "Specific Client";
              container rib-client-redist-stats {
                description
                  "Redist statistics of a specific client";
                container route {
                  description "route";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf update-sent {
                    type uint32;
                    description "update sent";
                  }
    
                  leaf paths-sent {
                    type uint32;
                    description "paths sent";
                  }
    
                  leaf prefixes-deleted {
                    type uint32;
                    description
                      "prefixes deleted";
                  }
    
                  leaf total-advertisment {
                    type uint32;
                    description
                      "total advertisment";
                  }
    
                  leaf last-redist-delete {
                    type boolean;
                    description
                      "last redist delete";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container route
    
                container attr {
                  description "attr";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-tbl-entries {
                    type uint32;
                    description
                      "total tbl entries";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container attr
    
                container srv6 {
                  description "srv6";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container srv6
    
                leaf protocol-name {
                  type string;
                  description
                    " Name of Protocol";
                }
    
                leaf instance {
                  type string;
                  description "Instance name";
                }
    
                list opaque-stat {
                  max-elements 16;
                  description "opaque stat";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-tbl-entries {
                    type uint32;
                    description
                      "total tbl entries";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // list opaque-stat
              }  // container rib-client-redist-stats
    
              container rib-client-stats-client {
                description
                  "Client statistics of a specific client";
                container notification {
                  description "notification";
                  container evt-hist {
                    description "evt hist";
                    leaf evt-class-name {
                      type string;
                      description
                        "Class name string";
                    }
    
                    list evt-entry {
                      description
                        "Array of event entries";
                      leaf evt-timestamp {
                        type string;
                        description
                          "The timestamp of the event";
                      }
    
                      leaf evt-name {
                        type string;
                        description "Event name";
                      }
    
                      leaf evt-type {
                        type uint8;
                        description "Event type";
                      }
    
                      leaf evt-many {
                        type boolean;
                        description
                          "Multiple instance flag";
                      }
    
                      leaf evt-sticky {
                        type boolean;
                        description
                          "Sticky flag";
                      }
    
                      list evt-data {
                        description
                          "Optional data";
                        leaf entry {
                          type uint32;
                          description
                            "Optional data";
                        }
                      }  // list evt-data
                    }  // list evt-entry
                  }  // container evt-hist
    
                  leaf total-notifications {
                    type uint32;
                    description
                      "total notifications";
                  }
    
                  leaf clear {
                    type uint32;
                    description "clear";
                  }
    
                  leaf nexthop-critical {
                    type uint32;
                    description
                      "nexthop critical";
                  }
    
                  leaf nexthop-noncritical {
                    type uint32;
                    description
                      "nexthop noncritical";
                  }
    
                  leaf nexthop-converge {
                    type uint32;
                    description
                      "nexthop converge";
                  }
    
                  leaf redist-register {
                    type uint32;
                    description
                      "redist register";
                  }
    
                  leaf redist-reset {
                    type uint32;
                    description "redist reset";
                  }
    
                  leaf preceeding-client {
                    type uint32;
                    description
                      "preceeding client";
                  }
    
                  leaf redist-list {
                    type uint32;
                    description "redist list";
                  }
    
                  leaf gc-proto {
                    type uint32;
                    description "gc proto";
                  }
    
                  leaf gc-db {
                    type uint32;
                    description "gc db";
                  }
    
                  leaf gc-attribute {
                    type uint32;
                    description "gc attribute";
                  }
    
                  leaf table-event {
                    type uint32;
                    description "table event";
                  }
    
                  leaf feedback-cookie {
                    type uint32;
                    description
                      "feedback cookie";
                  }
    
                  leaf fib-ug-update {
                    type uint32;
                    description "fib ug update";
                  }
    
                  leaf critical {
                    type uint32;
                    description "critical";
                  }
    
                  leaf non-critical {
                    type uint32;
                    description "non critical";
                  }
    
                  leaf delay-timer {
                    type uint32;
                    description "delay timer";
                  }
    
                  leaf skip-notification {
                    type uint32;
                    description
                      "skip notification";
                  }
    
                  leaf end-of-data {
                    type uint32;
                    description "end of data";
                  }
    
                  leaf disconnect {
                    type uint32;
                    description "disconnect";
                  }
    
                  leaf srv6-redist-register {
                    type uint32;
                    description
                      "srv6 redist register";
                  }
    
                  leaf srv6-cfg-updt {
                    type uint32;
                    description "srv6 cfg updt";
                  }
    
                  leaf srv6-opcode-updt {
                    type uint32;
                    description
                      "srv6 opcode updt";
                  }
    
                  leaf state-sync-done {
                    type uint32;
                    description
                      "state sync done";
                  }
    
                  leaf last-notification {
                    type uint64;
                    description
                      "last notification";
                  }
    
                  leaf last-eod {
                    type uint64;
                    description "last eod";
                  }
    
                  leaf total-pulse {
                    type uint64;
                    description "total pulse";
                  }
    
                  leaf total-select {
                    type uint64;
                    description "total select";
                  }
    
                  leaf total-read {
                    type uint64;
                    description "total read";
                  }
                }  // container notification
    
                container redist {
                  description "redist";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container redist
    
                container tbl-stats {
                  description "tbl stats";
                  leaf total-table-register {
                    type uint32;
                    description
                      "total table register";
                  }
    
                  leaf new-table {
                    type uint32;
                    description "new table";
                  }
    
                  leaf modification {
                    type uint32;
                    description "modification";
                  }
    
                  leaf deletion {
                    type uint32;
                    description "deletion";
                  }
    
                  leaf cl-lookup-err {
                    type uint32;
                    description "cl lookup err";
                  }
    
                  leaf tbl-lookup-err {
                    type uint32;
                    description "tbl lookup err";
                  }
    
                  leaf invalid-id-lookup-err {
                    type uint32;
                    description
                      "invalid id lookup err";
                  }
    
                  leaf tbl-create-err {
                    type uint32;
                    description "tbl create err";
                  }
    
                  leaf success {
                    type uint32;
                    description "success";
                  }
    
                  leaf last-result {
                    type boolean;
                    description "last result";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // container tbl-stats
    
                container redist-tbl {
                  description "redist tbl";
                  leaf total-table-redist {
                    type uint32;
                    description
                      "total table redist";
                  }
    
                  leaf table-created {
                    type uint32;
                    description "table created";
                  }
    
                  leaf table-full {
                    type uint32;
                    description "table full";
                  }
    
                  leaf has-space {
                    type uint32;
                    description "has space";
                  }
    
                  leaf last-redist {
                    type uint8;
                    description "last redist";
                  }
    
                  leaf last-redist-time {
                    type uint64;
                    description
                      "last redist time";
                  }
                }  // container redist-tbl
    
                container attribute {
                  description "attribute";
                  leaf total-registration {
                    type uint32;
                    description
                      "total registration";
                  }
    
                  leaf total-add {
                    type uint32;
                    description "total add";
                  }
    
                  leaf success {
                    type uint32;
                    description "success";
                  }
    
                  leaf last-result {
                    type boolean;
                    description "last result";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // container attribute
    
                container lookups {
                  description "lookups";
                  leaf best-local-address {
                    type uint32;
                    description
                      "best local address";
                  }
    
                  leaf is-connected {
                    type uint32;
                    description "is connected";
                  }
    
                  leaf route-lookups {
                    type uint32;
                    description "route lookups";
                  }
    
                  leaf next-hop-lookups {
                    type uint32;
                    description
                      "next hop lookups";
                  }
    
                  leaf default-source {
                    type uint32;
                    description "default source";
                  }
                }  // container lookups
    
                container fib-ug {
                  description "fib ug";
                  leaf fib-ug-updates {
                    type uint32;
                    description "fib ug updates";
                  }
    
                  leaf fib-ug-total-nodes {
                    type uint32;
                    description
                      "fib ug total nodes";
                  }
                }  // container fib-ug
    
                container ug-start-stats {
                  description "ug start stats";
                  leaf bcdl-ug-notify-num-not-started {
                    type uint32;
                    description
                      "bcdl ug notify num not started";
                  }
    
                  leaf bcdl-ug-last-notify-not-started-time {
                    type uint64;
                    description
                      "bcdl ug last notify not started time";
                  }
                }  // container ug-start-stats
    
                leaf client-id {
                  type uint32;
                  description "client id";
                }
              }  // container rib-client-stats-client
    
              container rib-client-stats {
                description
                  "Statistics of table of a specific client";
                list rib-client-stat {
                  key "table-id";
                  description "Specific Table";
                  container rib-client-stats-protos {
                    description
                      "Statistics of table of protocol of a
    specific client";
                    list rib-client-stats-proto {
                      key "proto-id";
                      description
                        "Specific proto id";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      container route-op-stats {
                        description
                          "route op stats";
                        leaf paths-add-op {
                          type uint32;
                          description
                            "paths add op";
                        }
    
                        leaf prefix-added {
                          type uint32;
                          description
                            "prefix added";
                        }
    
                        leaf paths-added {
                          type uint32;
                          description
                            "paths added";
                        }
    
                        leaf prefix-modified-add {
                          type uint32;
                          description
                            "prefix modified add";
                        }
    
                        leaf paths-delete-op {
                          type uint32;
                          description
                            "paths delete op";
                        }
    
                        leaf prefix-deleted {
                          type uint32;
                          description
                            "prefix deleted";
                        }
    
                        leaf paths-deleted {
                          type uint32;
                          description
                            "paths deleted";
                        }
    
                        leaf prefix-modified-del {
                          type uint32;
                          description
                            "prefix modified del";
                        }
    
                        leaf prefix-flushed {
                          type uint32;
                          description
                            "prefix flushed";
                        }
    
                        leaf paths-flushed {
                          type uint32;
                          description
                            "paths flushed";
                        }
    
                        leaf invalid-op {
                          type uint32;
                          description
                            "invalid op";
                        }
    
                        leaf flushed {
                          type uint32;
                          description "flushed";
                        }
    
                        leaf too-manypaths {
                          type uint32;
                          description
                            "too manypaths";
                        }
    
                        leaf invalid-parameter {
                          type uint32;
                          description
                            "invalid parameter";
                        }
    
                        leaf no-ecmp-support {
                          type uint32;
                          description
                            "no ecmp support";
                        }
    
                        leaf mem-alloc-error {
                          type uint32;
                          description
                            "mem alloc error";
                        }
    
                        leaf path-backup {
                          type uint32;
                          description
                            "path backup";
                        }
    
                        leaf path-active {
                          type uint32;
                          description
                            "path active";
                        }
    
                        leaf path-change {
                          type uint32;
                          description
                            "path change";
                        }
    
                        leaf path-nochange {
                          type uint32;
                          description
                            "path nochange";
                        }
    
                        leaf table-limit {
                          type uint32;
                          description
                            "table limit";
                        }
    
                        leaf outsync {
                          type uint32;
                          description "outsync";
                        }
    
                        leaf last-outsync {
                          type uint64;
                          description
                            "last outsync";
                        }
    
                        leaf last-route-opt {
                          type uint16;
                          description
                            "last route opt";
                        }
    
                        leaf last-result {
                          type uint32;
                          description
                            "last result";
                        }
    
                        leaf last-opt-time {
                          type uint64;
                          description
                            "last opt time";
                        }
    
                        leaf attribute-not-found {
                          type uint32;
                          description
                            "attribute not found";
                        }
    
                        leaf last-attribute-not-found-time {
                          type uint64;
                          description
                            "last attribute not found time";
                        }
    
                        leaf num-fb-cookies {
                          type uint32;
                          description
                            "num fb cookies";
                        }
    
                        leaf last-fb-cookie-op {
                          type uint64;
                          description
                            "last fb cookie op";
                        }
    
                        leaf invalid-path-combination {
                          type uint32;
                          description
                            "invalid path combination";
                        }
    
                        leaf invalid-pathid-change {
                          type uint32;
                          description
                            "invalid pathid change";
                        }
    
                        leaf path-attribute-too-large {
                          type uint32;
                          description
                            "path attribute too large";
                        }
                      }  // container route-op-stats
    
                      container adv {
                        description "adv";
                        leaf total-adv {
                          type uint32;
                          description
                            "total adv";
                        }
    
                        leaf new-adv {
                          type uint32;
                          description "new adv";
                        }
    
                        leaf modification {
                          type uint32;
                          description
                            "modification";
                        }
    
                        leaf delete {
                          type uint32;
                          description "delete";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-result {
                          type boolean;
                          description
                            "last result";
                        }
    
                        leaf last-adv-time {
                          type uint64;
                          description
                            "last adv time";
                        }
                      }  // container adv
    
                      container complete-stats {
                        description
                          "complete stats";
                        leaf total-complete {
                          type uint32;
                          description
                            "total complete";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf last-complete-msg {
                          type uint64;
                          description
                            "last complete msg";
                        }
                      }  // container complete-stats
    
                      container converge-stats {
                        description
                          "converge stats";
                        leaf total-converge {
                          type uint32;
                          description
                            "total converge";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf bad-args {
                          type uint32;
                          description "bad args";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-converge-msg {
                          type uint64;
                          description
                            "last converge msg";
                        }
                      }  // container converge-stats
    
                      container complete-update-stats {
                        description
                          "complete update stats";
                        leaf total-complete {
                          type uint32;
                          description
                            "total complete";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf bad-args {
                          type uint32;
                          description "bad args";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-complete-msg {
                          type uint64;
                          description
                            "last complete msg";
                        }
                      }  // container complete-update-stats
    
                      container purge-stats {
                        description
                          "purge stats";
                        leaf total-purges {
                          type uint32;
                          description
                            "total purges";
                        }
    
                        leaf total-prefix-deleted {
                          type uint32;
                          description
                            "total prefix deleted";
                        }
    
                        leaf total-paths-deleted {
                          type uint32;
                          description
                            "total paths deleted";
                        }
    
                        leaf last-purge {
                          type uint64;
                          description
                            "last purge";
                        }
                      }  // container purge-stats
    
                      container nh-stats {
                        description "nh stats";
                        leaf table-id-xr {
                          type uint32;
                          description
                            "table id xr";
                        }
    
                        leaf vrf-name {
                          type string;
                          description "vrf name";
                        }
    
                        leaf total-next-hop-reg {
                          type uint32;
                          description
                            "total next hop reg";
                        }
    
                        leaf total-next-hop-unreg {
                          type uint32;
                          description
                            "total next hop unreg";
                        }
    
                        leaf total-sync-reg {
                          type uint32;
                          description
                            "total sync reg";
                        }
    
                        leaf last-registration {
                          type uint64;
                          description
                            "last registration";
                        }
                      }  // container nh-stats
    
                      leaf protocol-name {
                        type string;
                        description
                          " Name of Protocol";
                      }
    
                      leaf instance {
                        type string;
                        description
                          "Instance name";
                      }
    
                      list opaque-stat {
                        max-elements 16;
                        description
                          "opaque stat";
                        leaf total-registration {
                          type uint32;
                          description
                            "total registration";
                        }
    
                        leaf total-add {
                          type uint32;
                          description
                            "total add";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-result {
                          type boolean;
                          description
                            "last result";
                        }
    
                        leaf last-registration {
                          type uint64;
                          description
                            "last registration";
                        }
                      }  // list opaque-stat
                    }  // list rib-client-stats-proto
                  }  // container rib-client-stats-protos
    
                  leaf table-id {
                    type xr:Cisco-ios-xr-string;
                    description "Table Id";
                  }
                }  // list rib-client-stat
              }  // container rib-client-stats
    
              container rib-client-stats-nexthops {
                description
                  "Statistics of table of a specific client";
                list rib-client-stats-nexthop {
                  key "table-id";
                  description "Specific Table";
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
    
                  leaf table-id-xr {
                    type uint32;
                    description "table id xr";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "vrf name";
                  }
    
                  leaf total-next-hop-reg {
                    type uint32;
                    description
                      "total next hop reg";
                  }
    
                  leaf total-next-hop-unreg {
                    type uint32;
                    description
                      "total next hop unreg";
                  }
    
                  leaf total-sync-reg {
                    type uint32;
                    description "total sync reg";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // list rib-client-stats-nexthop
              }  // container rib-client-stats-nexthops
    
              container rib-client-proto {
                description
                  "Information of protocols of client";
                container rib-client-proto-table-ids {
                  description
                    "Client Protocol table";
                  list rib-client-proto-table-id {
                    key "tableid";
                    description
                      "Table ID for a given protocol under a given
    client";
                    container rib-client-proto-ids {
                      description
                        "Protocols list under a given table under a
    given client";
                      list rib-client-proto-id {
                        key "protoid";
                        description
                          "Information of protocols under a given
    table under a given client";
                        leaf protoid {
                          type uint32 {
                            range "0..96";
                          }
                          description "Proto ID";
                        }
    
                        leaf protocol-names {
                          type string;
                          description
                            "Name of proto";
                        }
    
                        leaf proto-instance {
                          type string;
                          description
                            "Instance of proto";
                        }
    
                        leaf distance {
                          type uint32;
                          description
                            "Route distane for the protocol";
                        }
    
                        leaf maxmetric {
                          type uint32;
                          description
                            "Route metric for the protocol";
                        }
    
                        leaf purgetime {
                          type uint32;
                          description
                            "Route purgetime";
                        }
    
                        leaf update-complete {
                          type boolean;
                          description
                            "Has the client finished updating";
                        }
                      }  // list rib-client-proto-id
                    }  // container rib-client-proto-ids
    
                    container rib-client-proto-table-info {
                      description
                        "Information of a specifc table under a
    given protocol under a given client";
                      leaf num-protos-outsync {
                        type uint32;
                        description
                          "Count of out-of-sync protocols";
                      }
    
                      leaf update-time {
                        type uint64;
                        units "nanosecond";
                        description
                          "Time of last update (nanoseconds)";
                      }
    
                      leaf afi {
                        type uint32;
                        description
                          "Address Family";
                      }
    
                      leaf safi {
                        type uint32;
                        description
                          "sub Address Family";
                      }
    
                      leaf vrf-name {
                        type string;
                        description
                          "VRF Name of the table";
                      }
                    }  // container rib-client-proto-table-info
    
                    leaf tableid {
                      type xr:Cisco-ios-xr-string;
                      description "Table Id";
                    }
                  }  // list rib-client-proto-table-id
                }  // container rib-client-proto-table-ids
    
                container rib-client-proto-info {
                  description
                    "Information of protocols of a specific client";
                  leaf num-protos-outsync {
                    type uint32;
                    description
                      "Count of out-of-sync protocols";
                  }
    
                  leaf update-time {
                    type uint32;
                    units "second";
                    description
                      "Time of last update in seconds";
                  }
                }  // container rib-client-proto-info
              }  // container rib-client-proto
    
              container rib-client-stats-redist-nexthops {
                description
                  "Statistics of nexthop table distribution";
                list rib-client-stats-redist-nexthop {
                  key "table-id";
                  description "Specific Table";
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
    
                  leaf table-id-xr {
                    type uint32;
                    description "table id xr";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "vrf name";
                  }
    
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-converge {
                    type uint32;
                    description "total converge";
                  }
    
                  leaf total-suppress {
                    type uint32;
                    description "total suppress";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
    
                  leaf total-converge-sent {
                    type uint32;
                    description
                      "total converge sent";
                  }
    
                  leaf last-converge {
                    type uint64;
                    description "last converge";
                  }
    
                  leaf last-converge-sent {
                    type uint64;
                    description
                      "last converge sent";
                  }
                }  // list rib-client-stats-redist-nexthop
              }  // container rib-client-stats-redist-nexthops
    
              container rib-client-info {
                description
                  "Information for a specific client";
                leaf pname {
                  type string;
                  description "Client's name";
                }
    
                leaf nodename {
                  type string;
                  description
                    "Node client process is running on";
                }
    
                leaf pid {
                  type uint32;
                  description
                    "Client's process ID";
                }
    
                leaf redist {
                  type boolean;
                  description
                    "Is client registered for redist";
                }
    
                leaf proto {
                  type boolean;
                  description
                    "Is client registered as a protocol";
                }
    
                leaf client-id {
                  type uint32;
                  description
                    "Client's RIB ID number";
                }
              }  // container rib-client-info
    
              container rib-client-redist-history {
                description
                  "History information of the table associated
    with a given redist under a specific client";
                container routes {
                  description
                    "Link to history routes";
                  list ipv4-rib-edm-client-history-route {
                    description "Next route";
                    container advertisement {
                      description
                        "list of advertising protos";
                      list ipv4-rib-edm-advert {
                        description
                          "Next advertising proto";
                        leaf protocol-id {
                          type uint32;
                          description
                            "Protocol advertising the route";
                        }
    
                        leaf client-id {
                          type uint32;
                          description
                            "  Client advertising the route";
                        }
    
                        leaf number-of-extended-communities {
                          type uint32;
                          description
                            "Number of extended communities attached by
    advertiser";
                        }
    
                        leaf extended-communities {
                          type yang:hex-string;
                          description
                            "Extended communities attached by the advertiser";
                        }
    
                        leaf protocol-opaque-flags {
                          type uint8;
                          description
                            "OSPF area-id flags";
                        }
    
                        leaf protocol-opaque {
                          type uint32;
                          description
                            "OSPF area-id";
                        }
    
                        leaf code {
                          type int8;
                          description
                            "Protocol code";
                        }
    
                        leaf instance-name {
                          type string {
                            length "0..41";
                          }
                          description
                            "Instance name of the protocol advertising the
    route";
                        }
                      }  // list ipv4-rib-edm-advert
                    }  // container advertisement
    
                    leaf prefix {
                      type Ipv4-rib-edm-addr;
                      description "Route prefix";
                    }
    
                    leaf prefix-length {
                      type uint8;
                      description
                        "Length of prefix";
                    }
    
                    leaf priority {
                      type uint8;
                      description
                        "Priority of update";
                    }
    
                    leaf flags {
                      type uint32;
                      description "Route flags";
                    }
    
                    leaf source {
                      type uint32;
                      description "source";
                    }
    
                    leaf table-id {
                      type uint32;
                      description
                        "table identifier";
                    }
    
                    leaf distance {
                      type uint32;
                      description
                        "Administrative distance";
                    }
    
                    leaf metric {
                      type uint32;
                      description "Route metric";
                    }
    
                    leaf local-label {
                      type uint32;
                      description
                        "Route local label";
                    }
    
                    leaf path-num {
                      type uint16;
                      description
                        "Number of paths";
                    }
    
                    leaf nnh-num {
                      type uint16;
                      description
                        "Number of NNHs";
                    }
    
                    leaf route-age {
                      type uint32;
                      units "second";
                      description
                        "Age of event (seconds)";
                    }
    
                    leaf route-modify-time {
                      type uint64;
                      units "nanosecond";
                      description
                        "Time of event (nanoseconds)";
                    }
    
                    leaf private-flags {
                      type uint16;
                      description
                        "Route head private flags";
                    }
    
                    leaf number-of-srv6-sids {
                      type uint16;
                      description
                        "Number of SRv6 Segment Identifiers";
                    }
    
                    leaf converge {
                      type uint8;
                      description
                        "Redist table converged";
                    }
    
                    leaf code {
                      type int8;
                      description
                        "Protocol code";
                    }
    
                    leaf outsync {
                      type uint32;
                      description
                        "Last packed outsync prio";
                    }
                  }  // list ipv4-rib-edm-client-history-route
                }  // container routes
    
                leaf num-tables-outsync {
                  type uint32;
                  description
                    "Num tables to get updates from";
                }
    
                leaf num-history-routes {
                  type uint32;
                  description
                    "Number of history routes";
                }
              }  // container rib-client-redist-history
    
              container rib-client-redists {
                description
                  "RIB client redistribution";
                list rib-client-redist {
                  key "table-id";
                  description
                    "Id of RIB client redistribution Table";
                  container rib-client-redist-protos {
                    description "Client proto";
                    list rib-client-redist-proto {
                      key "proto-id";
                      description
                        "Protocols information for a specific client";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      leaf insync {
                        type boolean;
                        description
                          "Is this in sync or not?";
                      }
    
                      leaf protocol-names {
                        type string;
                        description
                          "Name of proto it is redistributing";
                      }
    
                      leaf proto-instance {
                        type string;
                        description
                          "Instance of redistributed proto";
                      }
    
                      leaf updatemode {
                        type uint32;
                        description
                          "Type of route information getting redistributed";
                      }
                    }  // list rib-client-redist-proto
                  }  // container rib-client-redist-protos
    
                  container rib-client-redist-info {
                    description
                      "Information for a specific redistribution
    table under a given client";
                    leaf full-table {
                      type boolean;
                      description
                        "Full table redistrbution or not?";
                    }
    
                    leaf insync {
                      type uint32;
                      description
                        "Is this is sync or not?";
                    }
    
                    leaf afi {
                      type uint32;
                      description
                        "Address Family";
                    }
    
                    leaf safi {
                      type uint32;
                      description
                        "sub Address Family";
                    }
    
                    leaf vrf-name {
                      type string;
                      description
                        "VRF Name of the table";
                    }
    
                    leaf updatemode {
                      type uint32;
                      description
                        "Update type in route registration";
                    }
                  }  // container rib-client-redist-info
    
                  leaf table-id {
                    type xr:Cisco-ios-xr-string;
                    description "Table Id";
                  }
                }  // list rib-client-redist
              }  // container rib-client-redists
    
              container rib-client-stats-redists {
                description
                  "Statistics of table distribution";
                list rib-client-stats-redist {
                  key "table-id";
                  description "Specific Table";
                  container rib-client-stats-redist-protos {
                    description
                      "Protocol under a given table";
                    list rib-client-stats-redist-proto {
                      key "proto-id";
                      description
                        "Specific protocol";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      container route {
                        description "route";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf update-sent {
                          type uint32;
                          description
                            "update sent";
                        }
    
                        leaf paths-sent {
                          type uint32;
                          description
                            "paths sent";
                        }
    
                        leaf prefixes-deleted {
                          type uint32;
                          description
                            "prefixes deleted";
                        }
    
                        leaf total-advertisment {
                          type uint32;
                          description
                            "total advertisment";
                        }
    
                        leaf last-redist-delete {
                          type boolean;
                          description
                            "last redist delete";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container route
    
                      container attr {
                        description "attr";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf total-tbl-entries {
                          type uint32;
                          description
                            "total tbl entries";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container attr
    
                      container srv6 {
                        description "srv6";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container srv6
    
                      leaf protocol-name {
                        type string;
                        description
                          " Name of Protocol";
                      }
    
                      leaf instance {
                        type string;
                        description
                          "Instance name";
                      }
    
                      list opaque-stat {
                        max-elements 16;
                        description
                          "opaque stat";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf total-tbl-entries {
                          type uint32;
                          description
                            "total tbl entries";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // list opaque-stat
                    }  // list rib-client-stats-redist-proto
                  }  // container rib-client-stats-redist-protos
    
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
                }  // list rib-client-stats-redist
              }  // container rib-client-stats-redists
    
              leaf clientid {
                type uint32 {
                  range "0..2501";
                }
                description "Client ID";
              }
            }  // list rib-client
          }  // container rib-clients
        }  // container rib-stdby
    
        container rib {
          config false;
          description "RIB operational data";
          container rib-nh-id-histories {
            description "nhids history";
            list rib-nh-id-history {
              key "nh-idi-hist-count";
              description "NH Id history count";
              leaf nh-idi-hist-count {
                type Nhid-hist-count-range;
                description "NH Id hist count";
              }
    
              leaf nhid {
                type uint32;
                description "nhid";
              }
    
              leaf nh-addr {
                type Ipv4-rib-edm-addr;
                description "nh addr";
              }
    
              leaf ifindex {
                type xr:Interface-name;
                description "ifindex";
              }
    
              leaf tableid {
                type uint32;
                description "tableid";
              }
    
              leaf operation {
                type uint32;
                description "operation";
              }
    
              leaf update {
                type uint32;
                description "update";
              }
    
              leaf oper-time {
                type uint64;
                description "oper time";
              }
    
              leaf feature-type {
                type uint8;
                description "feature type";
              }
    
              leaf chkpt-obj-id {
                type uint32;
                description "chkpt obj id";
              }
            }  // list rib-nh-id-history
          }  // container rib-nh-id-histories
    
          container rib-update-groups {
            description "RIB UpdateGroup table";
            list rib-update-group {
              key "update-group-id";
              description "UpdateGroup id";
              container rib-update-group-info {
                description
                  "Information of specific updategroup";
                leaf ug-id {
                  type uint32;
                  description "Update Group ID";
                }
    
                leaf client-id {
                  type uint32;
                  description
                    "ClientId associated with UG";
                }
    
                leaf parent-id {
                  type int32;
                  description
                    "UG's parent if child";
                }
    
                leaf insync {
                  type boolean;
                  description
                    "Is this ug insync with RIB";
                }
    
                leaf freezecnt {
                  type uint32;
                  description
                    "Freeze count if frozen";
                }
              }  // container rib-update-group-info
    
              leaf update-group-id {
                type uint32;
                description "UpdateGroup Id";
              }
            }  // list rib-update-group
          }  // container rib-update-groups
    
          container rib-update-group-pruned-nodes {
            description
              "Information of updategroup pruned nodes";
            container rib-update-group-pruned-nodes-info {
              description
                "Information of updategroup pruned nodes";
              leaf num-pruned-nodes {
                type uint32;
                description
                  "Number of pruned nodes";
              }
    
              list pruned-node {
                max-elements 256;
                description "Pruned nodes ID";
                leaf entry {
                  type uint32;
                  description "Pruned nodes ID";
                }
              }  // list pruned-node
            }  // container rib-update-group-pruned-nodes-info
          }  // container rib-update-group-pruned-nodes
    
          container vrfs {
            description "VRF table";
            list vrf {
              key "vrf-name";
              description "Specific VRF";
              container afs {
                description
                  "Address Family (AF) table";
                list af {
                  key "af-name";
                  description
                    "Specific AF information";
                  container safs {
                    description
                      "Subsequent Address Family (SAF) table";
                    list saf {
                      key "saf-name";
                      description
                        "Specific SAF information";
                      container ip-rib-route-table-names {
                        description
                          "Global container of routes";
                        list ip-rib-route-table-name {
                          key "route-table-name";
                          description
                            "IP RIB Route table name for a topology";
                          container routes {
                            description
                              "Route information ";
                            list route {
                              key "address prefix-length";
                              description
                                "Route information of a specific Network
    Address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Network Address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the network address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list route
                          }  // container routes
    
                          container deleted-routes {
                            description
                              "Deleted";
                            list deleted-route {
                              key "address prefix-length";
                              description
                                "Route information for a specific
    deleted address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Deleted network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the deleted network
    address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list deleted-route
                          }  // container deleted-routes
    
                          container destination-kw {
                            description
                              "Destination KW";
                            container dest-best-routes {
                              description
                                "Best Local";
                              list dest-best-route {
                                key "address";
                                description
                                  "Best local route information for a
    specific Address ";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-best-route
                            }  // container dest-best-routes
    
                            container dest-q-routes {
                              description
                                "Quarantine";
                              list dest-q-route {
                                key "address prefix-length";
                                description
                                  "Route information of a specific
    quarantined address ";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Quarantined network address";
                                }
    
                                leaf prefix-length {
                                  type xr:Ipv4-prefix-length;
                                  description
                                    "prefix length of the quarantined
    network address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-q-route
                            }  // container dest-q-routes
    
                            container dest-backup-kw {
                              description
                                "Backup";
                              container dest-backup-prefixes {
                                description
                                  "Backup adresses prefix table";
                                list dest-backup-prefix {
                                  key "address prefix-length";
                                  description
                                    "Route information of a specific
    Backup Address ";
                                  container dest-backup-routes {
                                    description
                                      "Backup adresses route table";
                                    list dest-backup-route {
                                      key "protoid";
                                      description
                                        "Route information of a specific
    Backup Address and Client ";
                                      leaf protoid {
                                        type uint32 {
                                          range
                                            "0..96";
                                        }
                                        description
                                          "Proto ID";
                                      }
    
                                      container srv6-info {
                                        description
                                          "SRv6 related information";
                                        container srv6-endpoint-behavior {
                                          description
                                            "SRv6 Endpoint behavior/type";
                                          leaf type {
                                            type Mgmt-srv6-endpoint;
                                            description
                                              "Behavior type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Behavior description";
                                          }
                                        }  // container srv6-endpoint-behavior
    
                                        container srv6-format {
                                          description
                                            "SRv6 Format";
                                          leaf type {
                                            type Mgmt-srv6-sid-fmt;
                                            description
                                              "Format type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Format description";
                                          }
                                        }  // container srv6-format
    
                                        leaf is-srv6-endpoint {
                                          type boolean;
                                          description
                                            "Route is an SRv6 Endpoint (local SID)";
                                        }
    
                                        leaf is-srv6-locator {
                                          type boolean;
                                          description
                                            "Route corresponds to an SRv6 remote locator";
                                        }
    
                                        leaf srv6-locator-algo {
                                          type uint8;
                                          description
                                            "SRv6 Algo corresponding to SRv6 remote locator";
                                        }
                                      }  // container srv6-info
    
                                      container route-path {
                                        description
                                          "Path(s) of the route";
                                        list ipv4-rib-edm-path {
                                          description
                                            "Next path";
                                          container l2-info {
                                            description
                                              "L2 Info for this path";
                                            leaf xcid {
                                              type uint32;
                                              description
                                                "L2 Cross Connect ID for this path";
                                            }
    
                                            leaf ac-interface {
                                              type xr:Interface-name;
                                              description
                                                "L2 AC Interface";
                                            }
                                          }  // container l2-info
    
                                          container srv6-info {
                                            description
                                              "SRv6 related information";
                                            container srv6-carrier-format {
                                              description
                                                "SRv6 Carrier Format";
                                              leaf type {
                                                type Mgmt-srv6-sid-fmt;
                                                description
                                                  "Format type";
                                              }
    
                                              leaf description {
                                                type string;
                                                description
                                                  "Format description";
                                              }
                                            }  // container srv6-carrier-format
    
                                            container srv6-headend-behavior {
                                              description
                                                "SRv6 headend behavior/type info";
                                              leaf type {
                                                type Mgmt-srv6-headend;
                                                description
                                                  "Behavior type";
                                              }
    
                                              leaf description {
                                                type string;
                                                description
                                                  "Behavior description";
                                              }
                                            }  // container srv6-headend-behavior
    
                                            container via-srv6-sid {
                                              description
                                                "Via-SRv6-SID value";
                                              leaf sid {
                                                type inet:ipv6-address;
                                                description
                                                  "Via-SRv6-SID value";
                                              }
    
                                              leaf resolution-length {
                                                type uint8;
                                                description
                                                  "FIB Resolution length";
                                              }
                                            }  // container via-srv6-sid
    
                                            leaf number-of-srv6-carriers {
                                              type uint8;
                                              description
                                                "Number of SRv6 Carriers";
                                            }
    
                                            leaf has-srv6-headend-behavior {
                                              type boolean;
                                              description
                                                "Path has some SRv6 head-end behavior associated";
                                            }
    
                                            leaf has-via-srv6-sid {
                                              type boolean;
                                              description
                                                "Via-SRv6-SID is present";
                                            }
    
                                            list srv6-carrier {
                                              description
                                                "List of SRv6 Carriers with one or more SIDs";
                                              leaf sid {
                                                type inet:ipv6-address;
                                                description
                                                  "SID value";
                                              }
                                            }  // list srv6-carrier
                                          }  // container srv6-info
    
                                          leaf address {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Nexthop";
                                          }
    
                                          leaf information-source {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Infosource";
                                          }
    
                                          leaf v6-nexthop {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type inet:ipv6-address;
                                            description
                                              "IPv6 nexthop for v4 over v6";
                                          }
    
                                          leaf v6-information-source {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type inet:ipv6-address;
                                            description
                                              "V6 Infosource";
                                          }
    
                                          leaf interface-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type xr:Interface-name;
                                            description
                                              "Interface handle for the path's nexthop";
                                          }
    
                                          leaf metric {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Metrics";
                                          }
    
                                          leaf load-metric {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Load Metrics";
                                          }
    
                                          leaf flags64 {
                                            type uint64;
                                            description
                                              "Flags extended to 64 bits";
                                          }
    
                                          leaf flags {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint16;
                                            description
                                              "Flags";
                                          }
    
                                          leaf private-flags {
                                            type uint16;
                                            description
                                              "Private Flags, used internally by RIB";
                                          }
    
                                          leaf minimum-recurse-length {
                                            type uint8;
                                            description
                                              "Minimum netmask length of recursive resolving
    route";
                                          }
    
                                          leaf looped {
                                            type boolean;
                                            description
                                              "Looping path";
                                          }
    
                                          leaf next-hop-table-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "The table to which the next hop belongs";
                                          }
    
                                          leaf next-hop-vrf-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "VRF Name of the nh table";
                                          }
    
                                          leaf next-hop-table-name {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "NH table name";
                                          }
    
                                          leaf next-hop-afi {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NH afi";
                                          }
    
                                          leaf next-hop-safi {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NH safi";
                                          }
    
                                          leaf route-label {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Label associated with this path";
                                          }
    
                                          leaf tunnel-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Tunnel ID associated with this path";
                                          }
    
                                          leaf pathid {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Path id of this path";
                                          }
    
                                          leaf backup-pathid {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Path id of this path's backup";
                                          }
    
                                          leaf ref-cnt-of-backup {
                                            type uint32;
                                            description
                                              "For backup paths, the number of active paths
    protected by the backup path";
                                          }
    
                                          leaf number-of-extended-communities {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Number of extended communities associated with
    this path";
                                          }
    
                                          leaf mvpn-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "MVPN attribute present";
                                          }
    
                                          leaf path-rt-present {
                                            type boolean;
                                            description
                                              "Path RT present";
                                          }
    
                                          leaf vrf-import-rt-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "VRFIMPORTRTPresent";
                                          }
    
                                          leaf source-asrt-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "SOURCEASRTPresent";
                                          }
    
                                          leaf source-rd-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "SOURCERDPresent";
                                          }
    
                                          leaf segmented-nexthop-present {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "Segmented NH attributes present for this path";
                                          }
    
                                          leaf number-of-nnh {
                                            type uint32;
                                            description
                                              "Number of Next Next Hops";
                                          }
    
                                          leaf next-hop-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "NHID associated with this path";
                                          }
    
                                          leaf next-hop-id-refcount {
                                            type uint32;
                                            description
                                              "NHID references";
                                          }
    
                                          leaf ospf-area-id {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type string;
                                            description
                                              "OSPF area associated with the path";
                                          }
    
                                          leaf has-labelstk {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type boolean;
                                            description
                                              "Path has a label stack";
                                          }
    
                                          leaf num-labels {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint8;
                                            description
                                              "Number of labels in stack";
                                          }
    
                                          leaf binding-label {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "binding Label for this path";
                                          }
    
                                          leaf nhid-feid {
                                            type uint64;
                                            description
                                              "Fib nhid encap id";
                                          }
    
                                          leaf mpls-feid {
                                            type uint64;
                                            description
                                              "Fib mpls encap id";
                                          }
    
                                          leaf has-vxlan-network-id {
                                            type boolean;
                                            description
                                              "VXLAN Network Identifier exists for this path";
                                          }
    
                                          leaf vxlan-network-id {
                                            type uint32;
                                            description
                                              "VXLAN Network Identifier for this path";
                                          }
    
                                          leaf has-xcid {
                                            type boolean;
                                            description
                                              "L2 Cross Connect ID exists for this path";
                                          }
    
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf has-span-diag-interface {
                                            type boolean;
                                            description
                                              "SPAN Diagnostics Interface exists for this path";
                                          }
    
                                          leaf span-diag-interface {
                                            type xr:Interface-name;
                                            description
                                              "SPAN Diagnostics Interface for this path";
                                          }
    
                                          leaf has-subscriber-parent-interface {
                                            type boolean;
                                            description
                                              "Subscriber Parent Interface exists for this
    path";
                                          }
    
                                          leaf subscriber-parent-interface {
                                            type xr:Interface-name;
                                            description
                                              "Subscriber Parent Interface for this path";
                                          }
    
                                          leaf interface-index-present {
                                            type boolean;
                                            description
                                              "Flag to indicate if interface index attribute
    is present for this path";
                                          }
    
                                          leaf interface-index-attribute {
                                            type uint32;
                                            description
                                              "Interface Index attribute";
                                          }
    
                                          leaf iid-present {
                                            type boolean;
                                            description
                                              "Internal ID present";
                                          }
    
                                          leaf iid {
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Internal ID attribute";
                                          }
    
                                          leaf has-l2-info {
                                            type boolean;
                                            description
                                              "L2 Info present for this path";
                                          }
    
                                          list remote-backup-addr {
                                            max-elements
                                              2;
                                            description
                                              "Remote backup node address";
                                            leaf entry {
                                              xr:event-telemetry "Subscribe Telemetry Event";
                                              type Ipv4-rib-edm-addr;
                                              description
                                                "Remote backup node address";
                                            }
                                          }  // list remote-backup-addr
    
                                          list labelstk {
                                            description
                                              "Outgoing label stack for this path";
                                            leaf entry {
                                              xr:event-telemetry "Subscribe Telemetry Event";
                                              type uint32;
                                              description
                                                "Outgoing label stack for this path";
                                            }
                                          }  // list labelstk
    
                                          list next-next-hop {
                                            description
                                              "List of Next Next Hops";
                                            leaf type {
                                              type Rib-edm-nnh;
                                              description
                                                "type";
                                            }
    
                                            leaf unknownval {
                                              when
                                                "../type = 'unknown'" {
                                                description
                                                  "../type = 'Unknown'";
                                              }
                                              type uint32;
                                              description
                                                "Unknown Value";
                                            }
    
                                            leaf address {
                                              when
                                                "../type = 'ipv4-address'" {
                                                description
                                                  "../type = 'IPv4Address'";
                                              }
                                              type inet:ipv4-address;
                                              description
                                                "IPv4 Address";
                                            }
    
                                            leaf interface-index {
                                              when
                                                "../type = 'if-index'" {
                                                description
                                                  "../type = 'IfIndex'";
                                              }
                                              type uint32;
                                              description
                                                "Interface Index";
                                            }
                                          }  // list next-next-hop
                                        }  // list ipv4-rib-edm-path
                                      }  // container route-path
    
                                      leaf prefix {
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Route prefix";
                                      }
    
                                      leaf prefix-length-xr {
                                        type uint8;
                                        description
                                          "Length of prefix";
                                      }
    
                                      leaf route-version {
                                        type uint32;
                                        description
                                          "Route version, incremented by one on each active
    route change";
                                      }
    
                                      leaf protocol-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Protocol advertising the route";
                                      }
    
                                      leaf protocol-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          " Name of Protocol";
                                      }
    
                                      leaf instance {
                                        type string;
                                        description
                                          "Instance name";
                                      }
    
                                      leaf client-id {
                                        type uint32;
                                        description
                                          "Client adding the route to RIB";
                                      }
    
                                      leaf route-type {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint16;
                                        description
                                          "Type of route installed in RIB";
                                      }
    
                                      leaf priority {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Route priority";
                                      }
    
                                      leaf svd-type {
                                        type uint8;
                                        description
                                          "SVD Type of route";
                                      }
    
                                      leaf l2-route-type {
                                        type uint8;
                                        description
                                          "Type of route associated with L2 Service";
                                      }
    
                                      leaf flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Route flags";
                                      }
    
                                      leaf extended-flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint64;
                                        description
                                          "Extended Route flags";
                                      }
    
                                      leaf tag {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Opaque proto specific info";
                                      }
    
                                      leaf distance {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Distance of the route";
                                      }
    
                                      leaf diversion-distance {
                                        type uint32;
                                        description
                                          "Diversion distance of the route";
                                      }
    
                                      leaf metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Route metric";
                                      }
    
                                      leaf paths-count {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Number of paths";
                                      }
    
                                      leaf attribute-identity {
                                        type uint32;
                                        description
                                          "BGP Attribute ID";
                                      }
    
                                      leaf traffic-index {
                                        type uint8;
                                        description
                                          "BGP Traffic Index";
                                      }
    
                                      leaf route-precedence {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "IP precedence for this route";
                                      }
    
                                      leaf qos-group {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Route qos group";
                                      }
    
                                      leaf flow-tag {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Flow tag for this route";
                                      }
    
                                      leaf fwd-class {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Forward Class";
                                      }
    
                                      leaf pic-count {
                                        type uint8;
                                        description
                                          "Number of pic paths in this route";
                                      }
    
                                      leaf active {
                                        type boolean;
                                        description
                                          "Is the route active or backup";
                                      }
    
                                      leaf diversion {
                                        type boolean;
                                        description
                                          "Route has a diversion path";
                                      }
    
                                      leaf diversion-proto-name {
                                        type string;
                                        description
                                          "Diversion route protocol name";
                                      }
    
                                      leaf route-age {
                                        type uint32;
                                        units
                                          "second";
                                        description
                                          "Age of route (seconds)";
                                      }
    
                                      leaf route-label {
                                        type uint32;
                                        description
                                          "Local label of the route";
                                      }
    
                                      leaf version {
                                        type uint32;
                                        description
                                          "Route Version";
                                      }
    
                                      leaf tbl-version {
                                        type uint64;
                                        description
                                          "Table Version";
                                      }
    
                                      leaf route-modify-time {
                                        type uint64;
                                        units
                                          "nanosecond";
                                        description
                                          "Route modification time(nanoseconds)";
                                      }
    
                                      leaf prefix-feid {
                                        type uint64;
                                        description
                                          "Fib per-prefix encap id";
                                      }
    
                                      leaf number-of-algorithm-labels {
                                        type uint16;
                                        description
                                          "Number of Algorithm Labels associated with this
    prefix";
                                      }
    
                                      list algorithm-label {
                                        description
                                          "List of Algorithm Labels associated with this
    Prefix";
                                        leaf algorithm-id {
                                          type uint8;
                                          description
                                            "Algorithm Identifier";
                                        }
    
                                        leaf label {
                                          type uint32;
                                          description
                                            "Local label";
                                        }
    
                                        leaf metric {
                                          type uint32;
                                          description
                                            "Route Metric associated with Algorithm
    Identifier";
                                        }
                                      }  // list algorithm-label
                                    }  // list dest-backup-route
                                  }  // container dest-backup-routes
    
                                  leaf address {
                                    type inet:ipv4-address-no-zone;
                                    description
                                      "Backup network address";
                                  }
    
                                  leaf prefix-length {
                                    type xr:Ipv4-prefix-length;
                                    description
                                      "prefix length of the backup network
    address";
                                  }
                                }  // list dest-backup-prefix
                              }  // container dest-backup-prefixes
                            }  // container dest-backup-kw
    
                            container dest-next-hop-routes {
                              description
                                "Resolving next hop";
                              list dest-next-hop-route {
                                key "address";
                                description
                                  "Nexthop information for a specific
    address";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // list dest-next-hop-route
                            }  // container dest-next-hop-routes
                          }  // container destination-kw
    
                          container protocol {
                            description
                              "Contains the classification of routes by
    protocol";
                            container mobile {
                              description
                                "Mobile Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container mobile
    
                            container subscriber {
                              description
                                "Subscriber Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container subscriber
    
                            container connected {
                              description
                                "Connected Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container connected
    
                            container dagr {
                              description
                                "DAGR Protocol(Direct-Attached Gateway
    Redundancy) Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container dagr
    
                            container rip {
                              description
                                "RIP Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container rip
    
                            container ospf {
                              description
                                "OSPF Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container ospf
    
                            container srv6-local {
                              description
                                "SRv6-Local Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container srv6-local
    
                            container static {
                              description
                                "Static Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container static
    
                            container rpl {
                              description
                                "RPL Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container rpl
    
                            container application {
                              description
                                "Application Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container application
    
                            container te-client {
                              description
                                "TEClient Protocol";
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container te-client
    
                            container eigrp {
                              description
                                "EIGRP Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container eigrp
    
                            container local {
                              description
                                "Local Protocol";
                              container smiap {
                                description
                                  "SMIAP";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container smiap
    
                              container lspv {
                                description
                                  "LSPV(Label Switched Path Verification)
    Protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container lspv
    
                              container non-as {
                                description
                                  "Non Autonomous System of protocol";
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // container non-as
                            }  // container local
    
                            container bgp {
                              description
                                "BGP Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container bgp
    
                            container isis {
                              description
                                "ISIS Protocol";
                              list as {
                                key "as";
                                description
                                  "Autonomous System of protocol";
                                leaf as {
                                  type xr:Cisco-ios-xr-string;
                                  description
                                    "Autonomous system";
                                }
    
                                container protocol-routes {
                                  description
                                    "Protocol specific Route";
                                  list protocol-route {
                                    key "address prefix-length";
                                    description
                                      " Route information of a specific Network
    Address ";
                                    leaf address {
                                      type inet:ipv4-address-no-zone;
                                      description
                                        "Network address";
                                    }
    
                                    leaf prefix-length {
                                      type xr:Ipv4-prefix-length;
                                      description
                                        "Prefix Length of the network address";
                                    }
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-endpoint-behavior {
                                        description
                                          "SRv6 Endpoint behavior/type";
                                        leaf type {
                                          type Mgmt-srv6-endpoint;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-endpoint-behavior
    
                                      container srv6-format {
                                        description
                                          "SRv6 Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-format
    
                                      leaf is-srv6-endpoint {
                                        type boolean;
                                        description
                                          "Route is an SRv6 Endpoint (local SID)";
                                      }
    
                                      leaf is-srv6-locator {
                                        type boolean;
                                        description
                                          "Route corresponds to an SRv6 remote locator";
                                      }
    
                                      leaf srv6-locator-algo {
                                        type uint8;
                                        description
                                          "SRv6 Algo corresponding to SRv6 remote locator";
                                      }
                                    }  // container srv6-info
    
                                    container route-path {
                                      description
                                        "Path(s) of the route";
                                      list ipv4-rib-edm-path {
                                        description
                                          "Next path";
                                        container l2-info {
                                          description
                                            "L2 Info for this path";
                                          leaf xcid {
                                            type uint32;
                                            description
                                              "L2 Cross Connect ID for this path";
                                          }
    
                                          leaf ac-interface {
                                            type xr:Interface-name;
                                            description
                                              "L2 AC Interface";
                                          }
                                        }  // container l2-info
    
                                        container srv6-info {
                                          description
                                            "SRv6 related information";
                                          container srv6-carrier-format {
                                            description
                                              "SRv6 Carrier Format";
                                            leaf type {
                                              type Mgmt-srv6-sid-fmt;
                                              description
                                                "Format type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Format description";
                                            }
                                          }  // container srv6-carrier-format
    
                                          container srv6-headend-behavior {
                                            description
                                              "SRv6 headend behavior/type info";
                                            leaf type {
                                              type Mgmt-srv6-headend;
                                              description
                                                "Behavior type";
                                            }
    
                                            leaf description {
                                              type string;
                                              description
                                                "Behavior description";
                                            }
                                          }  // container srv6-headend-behavior
    
                                          container via-srv6-sid {
                                            description
                                              "Via-SRv6-SID value";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "Via-SRv6-SID value";
                                            }
    
                                            leaf resolution-length {
                                              type uint8;
                                              description
                                                "FIB Resolution length";
                                            }
                                          }  // container via-srv6-sid
    
                                          leaf number-of-srv6-carriers {
                                            type uint8;
                                            description
                                              "Number of SRv6 Carriers";
                                          }
    
                                          leaf has-srv6-headend-behavior {
                                            type boolean;
                                            description
                                              "Path has some SRv6 head-end behavior associated";
                                          }
    
                                          leaf has-via-srv6-sid {
                                            type boolean;
                                            description
                                              "Via-SRv6-SID is present";
                                          }
    
                                          list srv6-carrier {
                                            description
                                              "List of SRv6 Carriers with one or more SIDs";
                                            leaf sid {
                                              type inet:ipv6-address;
                                              description
                                                "SID value";
                                            }
                                          }  // list srv6-carrier
                                        }  // container srv6-info
    
                                        leaf address {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Nexthop";
                                        }
    
                                        leaf information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Infosource";
                                        }
    
                                        leaf v6-nexthop {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "IPv6 nexthop for v4 over v6";
                                        }
    
                                        leaf v6-information-source {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type inet:ipv6-address;
                                          description
                                            "V6 Infosource";
                                        }
    
                                        leaf interface-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type xr:Interface-name;
                                          description
                                            "Interface handle for the path's nexthop";
                                        }
    
                                        leaf metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Metrics";
                                        }
    
                                        leaf load-metric {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Load Metrics";
                                        }
    
                                        leaf flags64 {
                                          type uint64;
                                          description
                                            "Flags extended to 64 bits";
                                        }
    
                                        leaf flags {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint16;
                                          description
                                            "Flags";
                                        }
    
                                        leaf private-flags {
                                          type uint16;
                                          description
                                            "Private Flags, used internally by RIB";
                                        }
    
                                        leaf minimum-recurse-length {
                                          type uint8;
                                          description
                                            "Minimum netmask length of recursive resolving
    route";
                                        }
    
                                        leaf looped {
                                          type boolean;
                                          description
                                            "Looping path";
                                        }
    
                                        leaf next-hop-table-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "The table to which the next hop belongs";
                                        }
    
                                        leaf next-hop-vrf-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "VRF Name of the nh table";
                                        }
    
                                        leaf next-hop-table-name {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "NH table name";
                                        }
    
                                        leaf next-hop-afi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH afi";
                                        }
    
                                        leaf next-hop-safi {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NH safi";
                                        }
    
                                        leaf route-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Label associated with this path";
                                        }
    
                                        leaf tunnel-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Tunnel ID associated with this path";
                                        }
    
                                        leaf pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path";
                                        }
    
                                        leaf backup-pathid {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Path id of this path's backup";
                                        }
    
                                        leaf ref-cnt-of-backup {
                                          type uint32;
                                          description
                                            "For backup paths, the number of active paths
    protected by the backup path";
                                        }
    
                                        leaf number-of-extended-communities {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Number of extended communities associated with
    this path";
                                        }
    
                                        leaf mvpn-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "MVPN attribute present";
                                        }
    
                                        leaf path-rt-present {
                                          type boolean;
                                          description
                                            "Path RT present";
                                        }
    
                                        leaf vrf-import-rt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "VRFIMPORTRTPresent";
                                        }
    
                                        leaf source-asrt-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCEASRTPresent";
                                        }
    
                                        leaf source-rd-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "SOURCERDPresent";
                                        }
    
                                        leaf segmented-nexthop-present {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Segmented NH attributes present for this path";
                                        }
    
                                        leaf number-of-nnh {
                                          type uint32;
                                          description
                                            "Number of Next Next Hops";
                                        }
    
                                        leaf next-hop-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "NHID associated with this path";
                                        }
    
                                        leaf next-hop-id-refcount {
                                          type uint32;
                                          description
                                            "NHID references";
                                        }
    
                                        leaf ospf-area-id {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type string;
                                          description
                                            "OSPF area associated with the path";
                                        }
    
                                        leaf has-labelstk {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type boolean;
                                          description
                                            "Path has a label stack";
                                        }
    
                                        leaf num-labels {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint8;
                                          description
                                            "Number of labels in stack";
                                        }
    
                                        leaf binding-label {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "binding Label for this path";
                                        }
    
                                        leaf nhid-feid {
                                          type uint64;
                                          description
                                            "Fib nhid encap id";
                                        }
    
                                        leaf mpls-feid {
                                          type uint64;
                                          description
                                            "Fib mpls encap id";
                                        }
    
                                        leaf has-vxlan-network-id {
                                          type boolean;
                                          description
                                            "VXLAN Network Identifier exists for this path";
                                        }
    
                                        leaf vxlan-network-id {
                                          type uint32;
                                          description
                                            "VXLAN Network Identifier for this path";
                                        }
    
                                        leaf has-xcid {
                                          type boolean;
                                          description
                                            "L2 Cross Connect ID exists for this path";
                                        }
    
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf has-span-diag-interface {
                                          type boolean;
                                          description
                                            "SPAN Diagnostics Interface exists for this path";
                                        }
    
                                        leaf span-diag-interface {
                                          type xr:Interface-name;
                                          description
                                            "SPAN Diagnostics Interface for this path";
                                        }
    
                                        leaf has-subscriber-parent-interface {
                                          type boolean;
                                          description
                                            "Subscriber Parent Interface exists for this
    path";
                                        }
    
                                        leaf subscriber-parent-interface {
                                          type xr:Interface-name;
                                          description
                                            "Subscriber Parent Interface for this path";
                                        }
    
                                        leaf interface-index-present {
                                          type boolean;
                                          description
                                            "Flag to indicate if interface index attribute
    is present for this path";
                                        }
    
                                        leaf interface-index-attribute {
                                          type uint32;
                                          description
                                            "Interface Index attribute";
                                        }
    
                                        leaf iid-present {
                                          type boolean;
                                          description
                                            "Internal ID present";
                                        }
    
                                        leaf iid {
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Internal ID attribute";
                                        }
    
                                        leaf has-l2-info {
                                          type boolean;
                                          description
                                            "L2 Info present for this path";
                                        }
    
                                        list remote-backup-addr {
                                          max-elements
                                            2;
                                          description
                                            "Remote backup node address";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type Ipv4-rib-edm-addr;
                                            description
                                              "Remote backup node address";
                                          }
                                        }  // list remote-backup-addr
    
                                        list labelstk {
                                          description
                                            "Outgoing label stack for this path";
                                          leaf entry {
                                            xr:event-telemetry "Subscribe Telemetry Event";
                                            type uint32;
                                            description
                                              "Outgoing label stack for this path";
                                          }
                                        }  // list labelstk
    
                                        list next-next-hop {
                                          description
                                            "List of Next Next Hops";
                                          leaf type {
                                            type Rib-edm-nnh;
                                            description
                                              "type";
                                          }
    
                                          leaf unknownval {
                                            when
                                              "../type = 'unknown'" {
                                              description
                                                "../type = 'Unknown'";
                                            }
                                            type uint32;
                                            description
                                              "Unknown Value";
                                          }
    
                                          leaf address {
                                            when
                                              "../type = 'ipv4-address'" {
                                              description
                                                "../type = 'IPv4Address'";
                                            }
                                            type inet:ipv4-address;
                                            description
                                              "IPv4 Address";
                                          }
    
                                          leaf interface-index {
                                            when
                                              "../type = 'if-index'" {
                                              description
                                                "../type = 'IfIndex'";
                                            }
                                            type uint32;
                                            description
                                              "Interface Index";
                                          }
                                        }  // list next-next-hop
                                      }  // list ipv4-rib-edm-path
                                    }  // container route-path
    
                                    leaf prefix {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Route prefix";
                                    }
    
                                    leaf prefix-length-xr {
                                      type uint8;
                                      description
                                        "Length of prefix";
                                    }
    
                                    leaf route-version {
                                      type uint32;
                                      description
                                        "Route version, incremented by one on each active
    route change";
                                    }
    
                                    leaf protocol-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Protocol advertising the route";
                                    }
    
                                    leaf protocol-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        " Name of Protocol";
                                    }
    
                                    leaf instance {
                                      type string;
                                      description
                                        "Instance name";
                                    }
    
                                    leaf client-id {
                                      type uint32;
                                      description
                                        "Client adding the route to RIB";
                                    }
    
                                    leaf route-type {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Type of route installed in RIB";
                                    }
    
                                    leaf priority {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route priority";
                                    }
    
                                    leaf svd-type {
                                      type uint8;
                                      description
                                        "SVD Type of route";
                                    }
    
                                    leaf l2-route-type {
                                      type uint8;
                                      description
                                        "Type of route associated with L2 Service";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route flags";
                                    }
    
                                    leaf extended-flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint64;
                                      description
                                        "Extended Route flags";
                                    }
    
                                    leaf tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Opaque proto specific info";
                                    }
    
                                    leaf distance {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Distance of the route";
                                    }
    
                                    leaf diversion-distance {
                                      type uint32;
                                      description
                                        "Diversion distance of the route";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Route metric";
                                    }
    
                                    leaf paths-count {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of paths";
                                    }
    
                                    leaf attribute-identity {
                                      type uint32;
                                      description
                                        "BGP Attribute ID";
                                    }
    
                                    leaf traffic-index {
                                      type uint8;
                                      description
                                        "BGP Traffic Index";
                                    }
    
                                    leaf route-precedence {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "IP precedence for this route";
                                    }
    
                                    leaf qos-group {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Route qos group";
                                    }
    
                                    leaf flow-tag {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Flow tag for this route";
                                    }
    
                                    leaf fwd-class {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Forward Class";
                                    }
    
                                    leaf pic-count {
                                      type uint8;
                                      description
                                        "Number of pic paths in this route";
                                    }
    
                                    leaf active {
                                      type boolean;
                                      description
                                        "Is the route active or backup";
                                    }
    
                                    leaf diversion {
                                      type boolean;
                                      description
                                        "Route has a diversion path";
                                    }
    
                                    leaf diversion-proto-name {
                                      type string;
                                      description
                                        "Diversion route protocol name";
                                    }
    
                                    leaf route-age {
                                      type uint32;
                                      units
                                        "second";
                                      description
                                        "Age of route (seconds)";
                                    }
    
                                    leaf route-label {
                                      type uint32;
                                      description
                                        "Local label of the route";
                                    }
    
                                    leaf version {
                                      type uint32;
                                      description
                                        "Route Version";
                                    }
    
                                    leaf tbl-version {
                                      type uint64;
                                      description
                                        "Table Version";
                                    }
    
                                    leaf route-modify-time {
                                      type uint64;
                                      units
                                        "nanosecond";
                                      description
                                        "Route modification time(nanoseconds)";
                                    }
    
                                    leaf prefix-feid {
                                      type uint64;
                                      description
                                        "Fib per-prefix encap id";
                                    }
    
                                    leaf number-of-algorithm-labels {
                                      type uint16;
                                      description
                                        "Number of Algorithm Labels associated with this
    prefix";
                                    }
    
                                    list algorithm-label {
                                      description
                                        "List of Algorithm Labels associated with this
    Prefix";
                                      leaf algorithm-id {
                                        type uint8;
                                        description
                                          "Algorithm Identifier";
                                      }
    
                                      leaf label {
                                        type uint32;
                                        description
                                          "Local label";
                                      }
    
                                      leaf metric {
                                        type uint32;
                                        description
                                          "Route Metric associated with Algorithm
    Identifier";
                                      }
                                    }  // list algorithm-label
                                  }  // list protocol-route
                                }  // container protocol-routes
    
                                container information {
                                  description
                                    "Protocol related Information";
                                  leaf protocol-names {
                                    type string;
                                    description
                                      "Name";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name of the protocol";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Proto version";
                                  }
    
                                  leaf redistribution-client-count {
                                    type uint32;
                                    description
                                      "Number of redist clients";
                                  }
    
                                  leaf protocol-clients-count {
                                    type uint32;
                                    description
                                      "Number of proto clients";
                                  }
    
                                  leaf routes-counts {
                                    type uint32;
                                    description
                                      "Number of routes (including active, backup and
    deleted), where, number of backup routes =
    RoutesCounts - ActiveRoutesCount -
    DeletedRoutesCount ";
                                  }
    
                                  leaf active-routes-count {
                                    type uint32;
                                    description
                                      "Number of active routes (not deleted)";
                                  }
    
                                  leaf deleted-routes-count {
                                    type uint32;
                                    description
                                      "Number of deleted routes";
                                  }
    
                                  leaf paths-count {
                                    type uint32;
                                    description
                                      "Number of paths for all routes";
                                  }
    
                                  leaf protocol-route-memory {
                                    type uint32;
                                    units "byte";
                                    description
                                      "Memory for proto's routes and paths in bytes";
                                  }
    
                                  leaf backup-routes-count {
                                    type uint32;
                                    description
                                      "Number of backup routes";
                                  }
                                }  // container information
                              }  // list as
                            }  // container isis
                          }  // container protocol
    
                          container opaques {
                            description
                              "Opaque information ";
                            list opaque {
                              description
                                "Opaque item ";
                              leaf opaque-client-id {
                                type uint32 {
                                  range
                                    "0..2501";
                                }
                                description
                                  "Opaque Client ID";
                              }
    
                              leaf opaque-proto-id {
                                type uint32 {
                                  range "0..96";
                                }
                                description
                                  "Opaque Proto ID";
                              }
    
                              leaf opaque-key-type {
                                type uint32 {
                                  range "0..16";
                                }
                                description
                                  "The type of the opaque key installed
    in the RIB table";
                              }
    
                              leaf opaque-key-size {
                                type uint32 {
                                  range
                                    "0..4294967295";
                                }
                                description
                                  "The size of the opaque key installed
    in the RIB table";
                              }
    
                              leaf opaque-data-size {
                                type uint32 {
                                  range
                                    "0..4294967295";
                                }
                                description
                                  "The size of the opaque data installed
    in the RIB table";
                              }
    
                              leaf opaque-string {
                                type xr:Cisco-ios-xr-string;
                                description
                                  "The opaque data installed in the RIB
    table";
                              }
    
                              leaf key {
                                type yang:hex-string;
                                description
                                  "The unique ID assigned to the opaque object by
    client";
                              }
    
                              leaf data {
                                type yang:hex-string;
                                description
                                  "The data part of the opaque object";
                              }
                            }  // list opaque
                          }  // container opaques
    
                          container q-routes {
                            description
                              "Quarantine";
                            list q-route {
                              key "address prefix-length";
                              description
                                "Route information for a specific
    quarantined address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Quarantined network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the quarantined
    network address";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list q-route
                          }  // container q-routes
    
                          container longer-route-prefixes {
                            description
                              "Longer routes prefix table";
                            list longer-route-prefix {
                              description
                                "Net/mask to match longer routes";
                              container longer-route-last-prefixes {
                                description
                                  "Longer route last prefix table";
                                list longer-route-last-prefix {
                                  description
                                    "Information of all matching longer
    routes for a prefix/mask under a
    given table";
                                  leaf address {
                                    type inet:ipv4-address-no-zone;
                                    description
                                      "Network Address ";
                                  }
    
                                  leaf prefix-length {
                                    type xr:Ipv4-prefix-length;
                                    description
                                      "Prefix Length ";
                                  }
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-endpoint-behavior {
                                      description
                                        "SRv6 Endpoint behavior/type";
                                      leaf type {
                                        type Mgmt-srv6-endpoint;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-endpoint-behavior
    
                                    container srv6-format {
                                      description
                                        "SRv6 Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-format
    
                                    leaf is-srv6-endpoint {
                                      type boolean;
                                      description
                                        "Route is an SRv6 Endpoint (local SID)";
                                    }
    
                                    leaf is-srv6-locator {
                                      type boolean;
                                      description
                                        "Route corresponds to an SRv6 remote locator";
                                    }
    
                                    leaf srv6-locator-algo {
                                      type uint8;
                                      description
                                        "SRv6 Algo corresponding to SRv6 remote locator";
                                    }
                                  }  // container srv6-info
    
                                  container route-path {
                                    description
                                      "Path(s) of the route";
                                    list ipv4-rib-edm-path {
                                      description
                                        "Next path";
                                      container l2-info {
                                        description
                                          "L2 Info for this path";
                                        leaf xcid {
                                          type uint32;
                                          description
                                            "L2 Cross Connect ID for this path";
                                        }
    
                                        leaf ac-interface {
                                          type xr:Interface-name;
                                          description
                                            "L2 AC Interface";
                                        }
                                      }  // container l2-info
    
                                      container srv6-info {
                                        description
                                          "SRv6 related information";
                                        container srv6-carrier-format {
                                          description
                                            "SRv6 Carrier Format";
                                          leaf type {
                                            type Mgmt-srv6-sid-fmt;
                                            description
                                              "Format type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Format description";
                                          }
                                        }  // container srv6-carrier-format
    
                                        container srv6-headend-behavior {
                                          description
                                            "SRv6 headend behavior/type info";
                                          leaf type {
                                            type Mgmt-srv6-headend;
                                            description
                                              "Behavior type";
                                          }
    
                                          leaf description {
                                            type string;
                                            description
                                              "Behavior description";
                                          }
                                        }  // container srv6-headend-behavior
    
                                        container via-srv6-sid {
                                          description
                                            "Via-SRv6-SID value";
                                          leaf sid {
                                            type inet:ipv6-address;
                                            description
                                              "Via-SRv6-SID value";
                                          }
    
                                          leaf resolution-length {
                                            type uint8;
                                            description
                                              "FIB Resolution length";
                                          }
                                        }  // container via-srv6-sid
    
                                        leaf number-of-srv6-carriers {
                                          type uint8;
                                          description
                                            "Number of SRv6 Carriers";
                                        }
    
                                        leaf has-srv6-headend-behavior {
                                          type boolean;
                                          description
                                            "Path has some SRv6 head-end behavior associated";
                                        }
    
                                        leaf has-via-srv6-sid {
                                          type boolean;
                                          description
                                            "Via-SRv6-SID is present";
                                        }
    
                                        list srv6-carrier {
                                          description
                                            "List of SRv6 Carriers with one or more SIDs";
                                          leaf sid {
                                            type inet:ipv6-address;
                                            description
                                              "SID value";
                                          }
                                        }  // list srv6-carrier
                                      }  // container srv6-info
    
                                      leaf address {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Nexthop";
                                      }
    
                                      leaf information-source {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Infosource";
                                      }
    
                                      leaf v6-nexthop {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type inet:ipv6-address;
                                        description
                                          "IPv6 nexthop for v4 over v6";
                                      }
    
                                      leaf v6-information-source {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type inet:ipv6-address;
                                        description
                                          "V6 Infosource";
                                      }
    
                                      leaf interface-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type xr:Interface-name;
                                        description
                                          "Interface handle for the path's nexthop";
                                      }
    
                                      leaf metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Metrics";
                                      }
    
                                      leaf load-metric {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Load Metrics";
                                      }
    
                                      leaf flags64 {
                                        type uint64;
                                        description
                                          "Flags extended to 64 bits";
                                      }
    
                                      leaf flags {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint16;
                                        description
                                          "Flags";
                                      }
    
                                      leaf private-flags {
                                        type uint16;
                                        description
                                          "Private Flags, used internally by RIB";
                                      }
    
                                      leaf minimum-recurse-length {
                                        type uint8;
                                        description
                                          "Minimum netmask length of recursive resolving
    route";
                                      }
    
                                      leaf looped {
                                        type boolean;
                                        description
                                          "Looping path";
                                      }
    
                                      leaf next-hop-table-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "The table to which the next hop belongs";
                                      }
    
                                      leaf next-hop-vrf-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "VRF Name of the nh table";
                                      }
    
                                      leaf next-hop-table-name {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "NH table name";
                                      }
    
                                      leaf next-hop-afi {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NH afi";
                                      }
    
                                      leaf next-hop-safi {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NH safi";
                                      }
    
                                      leaf route-label {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Label associated with this path";
                                      }
    
                                      leaf tunnel-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Tunnel ID associated with this path";
                                      }
    
                                      leaf pathid {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Path id of this path";
                                      }
    
                                      leaf backup-pathid {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Path id of this path's backup";
                                      }
    
                                      leaf ref-cnt-of-backup {
                                        type uint32;
                                        description
                                          "For backup paths, the number of active paths
    protected by the backup path";
                                      }
    
                                      leaf number-of-extended-communities {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Number of extended communities associated with
    this path";
                                      }
    
                                      leaf mvpn-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "MVPN attribute present";
                                      }
    
                                      leaf path-rt-present {
                                        type boolean;
                                        description
                                          "Path RT present";
                                      }
    
                                      leaf vrf-import-rt-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "VRFIMPORTRTPresent";
                                      }
    
                                      leaf source-asrt-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "SOURCEASRTPresent";
                                      }
    
                                      leaf source-rd-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "SOURCERDPresent";
                                      }
    
                                      leaf segmented-nexthop-present {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "Segmented NH attributes present for this path";
                                      }
    
                                      leaf number-of-nnh {
                                        type uint32;
                                        description
                                          "Number of Next Next Hops";
                                      }
    
                                      leaf next-hop-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "NHID associated with this path";
                                      }
    
                                      leaf next-hop-id-refcount {
                                        type uint32;
                                        description
                                          "NHID references";
                                      }
    
                                      leaf ospf-area-id {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type string;
                                        description
                                          "OSPF area associated with the path";
                                      }
    
                                      leaf has-labelstk {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type boolean;
                                        description
                                          "Path has a label stack";
                                      }
    
                                      leaf num-labels {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint8;
                                        description
                                          "Number of labels in stack";
                                      }
    
                                      leaf binding-label {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "binding Label for this path";
                                      }
    
                                      leaf nhid-feid {
                                        type uint64;
                                        description
                                          "Fib nhid encap id";
                                      }
    
                                      leaf mpls-feid {
                                        type uint64;
                                        description
                                          "Fib mpls encap id";
                                      }
    
                                      leaf has-vxlan-network-id {
                                        type boolean;
                                        description
                                          "VXLAN Network Identifier exists for this path";
                                      }
    
                                      leaf vxlan-network-id {
                                        type uint32;
                                        description
                                          "VXLAN Network Identifier for this path";
                                      }
    
                                      leaf has-xcid {
                                        type boolean;
                                        description
                                          "L2 Cross Connect ID exists for this path";
                                      }
    
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf has-span-diag-interface {
                                        type boolean;
                                        description
                                          "SPAN Diagnostics Interface exists for this path";
                                      }
    
                                      leaf span-diag-interface {
                                        type xr:Interface-name;
                                        description
                                          "SPAN Diagnostics Interface for this path";
                                      }
    
                                      leaf has-subscriber-parent-interface {
                                        type boolean;
                                        description
                                          "Subscriber Parent Interface exists for this
    path";
                                      }
    
                                      leaf subscriber-parent-interface {
                                        type xr:Interface-name;
                                        description
                                          "Subscriber Parent Interface for this path";
                                      }
    
                                      leaf interface-index-present {
                                        type boolean;
                                        description
                                          "Flag to indicate if interface index attribute
    is present for this path";
                                      }
    
                                      leaf interface-index-attribute {
                                        type uint32;
                                        description
                                          "Interface Index attribute";
                                      }
    
                                      leaf iid-present {
                                        type boolean;
                                        description
                                          "Internal ID present";
                                      }
    
                                      leaf iid {
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Internal ID attribute";
                                      }
    
                                      leaf has-l2-info {
                                        type boolean;
                                        description
                                          "L2 Info present for this path";
                                      }
    
                                      list remote-backup-addr {
                                        max-elements
                                          2;
                                        description
                                          "Remote backup node address";
                                        leaf entry {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type Ipv4-rib-edm-addr;
                                          description
                                            "Remote backup node address";
                                        }
                                      }  // list remote-backup-addr
    
                                      list labelstk {
                                        description
                                          "Outgoing label stack for this path";
                                        leaf entry {
                                          xr:event-telemetry "Subscribe Telemetry Event";
                                          type uint32;
                                          description
                                            "Outgoing label stack for this path";
                                        }
                                      }  // list labelstk
    
                                      list next-next-hop {
                                        description
                                          "List of Next Next Hops";
                                        leaf type {
                                          type Rib-edm-nnh;
                                          description
                                            "type";
                                        }
    
                                        leaf unknownval {
                                          when
                                            "../type = 'unknown'" {
                                            description
                                              "../type = 'Unknown'";
                                          }
                                          type uint32;
                                          description
                                            "Unknown Value";
                                        }
    
                                        leaf address {
                                          when
                                            "../type = 'ipv4-address'" {
                                            description
                                              "../type = 'IPv4Address'";
                                          }
                                          type inet:ipv4-address;
                                          description
                                            "IPv4 Address";
                                        }
    
                                        leaf interface-index {
                                          when
                                            "../type = 'if-index'" {
                                            description
                                              "../type = 'IfIndex'";
                                          }
                                          type uint32;
                                          description
                                            "Interface Index";
                                        }
                                      }  // list next-next-hop
                                    }  // list ipv4-rib-edm-path
                                  }  // container route-path
    
                                  leaf prefix {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Route prefix";
                                  }
    
                                  leaf prefix-length-xr {
                                    type uint8;
                                    description
                                      "Length of prefix";
                                  }
    
                                  leaf route-version {
                                    type uint32;
                                    description
                                      "Route version, incremented by one on each active
    route change";
                                  }
    
                                  leaf protocol-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Protocol advertising the route";
                                  }
    
                                  leaf protocol-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      " Name of Protocol";
                                  }
    
                                  leaf instance {
                                    type string;
                                    description
                                      "Instance name";
                                  }
    
                                  leaf client-id {
                                    type uint32;
                                    description
                                      "Client adding the route to RIB";
                                  }
    
                                  leaf route-type {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Type of route installed in RIB";
                                  }
    
                                  leaf priority {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Route priority";
                                  }
    
                                  leaf svd-type {
                                    type uint8;
                                    description
                                      "SVD Type of route";
                                  }
    
                                  leaf l2-route-type {
                                    type uint8;
                                    description
                                      "Type of route associated with L2 Service";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Route flags";
                                  }
    
                                  leaf extended-flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint64;
                                    description
                                      "Extended Route flags";
                                  }
    
                                  leaf tag {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Opaque proto specific info";
                                  }
    
                                  leaf distance {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Distance of the route";
                                  }
    
                                  leaf diversion-distance {
                                    type uint32;
                                    description
                                      "Diversion distance of the route";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Route metric";
                                  }
    
                                  leaf paths-count {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of paths";
                                  }
    
                                  leaf attribute-identity {
                                    type uint32;
                                    description
                                      "BGP Attribute ID";
                                  }
    
                                  leaf traffic-index {
                                    type uint8;
                                    description
                                      "BGP Traffic Index";
                                  }
    
                                  leaf route-precedence {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "IP precedence for this route";
                                  }
    
                                  leaf qos-group {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Route qos group";
                                  }
    
                                  leaf flow-tag {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Flow tag for this route";
                                  }
    
                                  leaf fwd-class {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Forward Class";
                                  }
    
                                  leaf pic-count {
                                    type uint8;
                                    description
                                      "Number of pic paths in this route";
                                  }
    
                                  leaf active {
                                    type boolean;
                                    description
                                      "Is the route active or backup";
                                  }
    
                                  leaf diversion {
                                    type boolean;
                                    description
                                      "Route has a diversion path";
                                  }
    
                                  leaf diversion-proto-name {
                                    type string;
                                    description
                                      "Diversion route protocol name";
                                  }
    
                                  leaf route-age {
                                    type uint32;
                                    units
                                      "second";
                                    description
                                      "Age of route (seconds)";
                                  }
    
                                  leaf route-label {
                                    type uint32;
                                    description
                                      "Local label of the route";
                                  }
    
                                  leaf version {
                                    type uint32;
                                    description
                                      "Route Version";
                                  }
    
                                  leaf tbl-version {
                                    type uint64;
                                    description
                                      "Table Version";
                                  }
    
                                  leaf route-modify-time {
                                    type uint64;
                                    units
                                      "nanosecond";
                                    description
                                      "Route modification time(nanoseconds)";
                                  }
    
                                  leaf prefix-feid {
                                    type uint64;
                                    description
                                      "Fib per-prefix encap id";
                                  }
    
                                  leaf number-of-algorithm-labels {
                                    type uint16;
                                    description
                                      "Number of Algorithm Labels associated with this
    prefix";
                                  }
    
                                  list algorithm-label {
                                    description
                                      "List of Algorithm Labels associated with this
    Prefix";
                                    leaf algorithm-id {
                                      type uint8;
                                      description
                                        "Algorithm Identifier";
                                    }
    
                                    leaf label {
                                      type uint32;
                                      description
                                        "Local label";
                                    }
    
                                    leaf metric {
                                      type uint32;
                                      description
                                        "Route Metric associated with Algorithm
    Identifier";
                                    }
                                  }  // list algorithm-label
                                }  // list longer-route-last-prefix
                              }  // container longer-route-last-prefixes
    
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Network Address ";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix Length ";
                              }
                            }  // list longer-route-prefix
                          }  // container longer-route-prefixes
    
                          container nexthops {
                            description
                              "Nexthop notification registerations
    under a given table";
                            list nexthop {
                              description
                                "List the nexthop notification
    registeration under a given table";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Nexthop network address ";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the nexthop network
    address";
                              }
    
                              leaf unresolved-nh-tree {
                                type boolean;
                                description
                                  "Unresolved Nexthop Tree";
                              }
    
                              leaf exact-match {
                                type boolean;
                                description
                                  "Exact match";
                              }
    
                              leaf allow-default {
                                type boolean;
                                description
                                  "Allow Default";
                              }
    
                              leaf recurse {
                                type boolean;
                                description
                                  "Recurse";
                              }
    
                              leaf cross-table {
                                type boolean;
                                description
                                  "Cross table nextHop";
                              }
    
                              leaf pack-sfs {
                                type boolean;
                                description
                                  "Pack SFS paths for Multicast";
                              }
    
                              leaf pack-backup-paths {
                                type boolean;
                                description
                                  "Pack backup paths";
                              }
    
                              leaf backup-route {
                                type boolean;
                                description
                                  "Backup route notifications";
                              }
    
                              leaf best-metric {
                                type boolean;
                                description
                                  "Return lowest metric";
                              }
    
                              container clients {
                                description
                                  "Client(s) of the address";
                                list rib-edm-nh-client {
                                  description
                                    "Next client";
                                  leaf id {
                                    type uint32;
                                    description
                                      "Client id";
                                  }
    
                                  leaf ref-count {
                                    type uint32;
                                    description
                                      "The number NH reference this client";
                                  }
    
                                  leaf nh-create-age {
                                    type uint32;
                                    description
                                      "How long has client has been created";
                                  }
    
                                  leaf nh-create-time {
                                    type uint64;
                                    description
                                      "Client creation time";
                                  }
    
                                  leaf nh-read-age {
                                    type uint32;
                                    description
                                      "How long ago client read this notification";
                                  }
    
                                  leaf nh-read-time {
                                    type uint64;
                                    description
                                      "Client notification read time";
                                  }
    
                                  leaf pack-mvpn {
                                    type boolean;
                                    description
                                      "Pack MVPN";
                                  }
    
                                  leaf pack-path-rt {
                                    type boolean;
                                    description
                                      "Pack path RT";
                                  }
    
                                  leaf pack-vrf-import-rt {
                                    type boolean;
                                    description
                                      "Pack VRF import RT";
                                  }
    
                                  leaf pack-source-as-rt {
                                    type boolean;
                                    description
                                      "Pack source AS RT";
                                  }
    
                                  leaf pack-source-rd {
                                    type boolean;
                                    description
                                      "Pack source RD";
                                  }
    
                                  leaf pack-mldp-root {
                                    type boolean;
                                    description
                                      "Pack MLDP root";
                                  }
    
                                  leaf pack-seg-nh {
                                    type boolean;
                                    description
                                      "Pack seg NH";
                                  }
    
                                  leaf notify-reregister {
                                    type boolean;
                                    description
                                      "Notify Reregister";
                                  }
                                }  // list rib-edm-nh-client
                              }  // container clients
    
                              container resolved-route {
                                description
                                  "Route resolved this nexthop";
                                container srv6-info {
                                  description
                                    "SRv6 related information";
                                  container srv6-endpoint-behavior {
                                    description
                                      "SRv6 Endpoint behavior/type";
                                    leaf type {
                                      type Mgmt-srv6-endpoint;
                                      description
                                        "Behavior type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Behavior description";
                                    }
                                  }  // container srv6-endpoint-behavior
    
                                  container srv6-format {
                                    description
                                      "SRv6 Format";
                                    leaf type {
                                      type Mgmt-srv6-sid-fmt;
                                      description
                                        "Format type";
                                    }
    
                                    leaf description {
                                      type string;
                                      description
                                        "Format description";
                                    }
                                  }  // container srv6-format
    
                                  leaf is-srv6-endpoint {
                                    type boolean;
                                    description
                                      "Route is an SRv6 Endpoint (local SID)";
                                  }
    
                                  leaf is-srv6-locator {
                                    type boolean;
                                    description
                                      "Route corresponds to an SRv6 remote locator";
                                  }
    
                                  leaf srv6-locator-algo {
                                    type uint8;
                                    description
                                      "SRv6 Algo corresponding to SRv6 remote locator";
                                  }
                                }  // container srv6-info
    
                                container route-path {
                                  description
                                    "Path(s) of the route";
                                  list ipv4-rib-edm-path {
                                    description
                                      "Next path";
                                    container l2-info {
                                      description
                                        "L2 Info for this path";
                                      leaf xcid {
                                        type uint32;
                                        description
                                          "L2 Cross Connect ID for this path";
                                      }
    
                                      leaf ac-interface {
                                        type xr:Interface-name;
                                        description
                                          "L2 AC Interface";
                                      }
                                    }  // container l2-info
    
                                    container srv6-info {
                                      description
                                        "SRv6 related information";
                                      container srv6-carrier-format {
                                        description
                                          "SRv6 Carrier Format";
                                        leaf type {
                                          type Mgmt-srv6-sid-fmt;
                                          description
                                            "Format type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Format description";
                                        }
                                      }  // container srv6-carrier-format
    
                                      container srv6-headend-behavior {
                                        description
                                          "SRv6 headend behavior/type info";
                                        leaf type {
                                          type Mgmt-srv6-headend;
                                          description
                                            "Behavior type";
                                        }
    
                                        leaf description {
                                          type string;
                                          description
                                            "Behavior description";
                                        }
                                      }  // container srv6-headend-behavior
    
                                      container via-srv6-sid {
                                        description
                                          "Via-SRv6-SID value";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "Via-SRv6-SID value";
                                        }
    
                                        leaf resolution-length {
                                          type uint8;
                                          description
                                            "FIB Resolution length";
                                        }
                                      }  // container via-srv6-sid
    
                                      leaf number-of-srv6-carriers {
                                        type uint8;
                                        description
                                          "Number of SRv6 Carriers";
                                      }
    
                                      leaf has-srv6-headend-behavior {
                                        type boolean;
                                        description
                                          "Path has some SRv6 head-end behavior associated";
                                      }
    
                                      leaf has-via-srv6-sid {
                                        type boolean;
                                        description
                                          "Via-SRv6-SID is present";
                                      }
    
                                      list srv6-carrier {
                                        description
                                          "List of SRv6 Carriers with one or more SIDs";
                                        leaf sid {
                                          type inet:ipv6-address;
                                          description
                                            "SID value";
                                        }
                                      }  // list srv6-carrier
                                    }  // container srv6-info
    
                                    leaf address {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Nexthop";
                                    }
    
                                    leaf information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Infosource";
                                    }
    
                                    leaf v6-nexthop {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "IPv6 nexthop for v4 over v6";
                                    }
    
                                    leaf v6-information-source {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type inet:ipv6-address;
                                      description
                                        "V6 Infosource";
                                    }
    
                                    leaf interface-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type xr:Interface-name;
                                      description
                                        "Interface handle for the path's nexthop";
                                    }
    
                                    leaf metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Metrics";
                                    }
    
                                    leaf load-metric {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Load Metrics";
                                    }
    
                                    leaf flags64 {
                                      type uint64;
                                      description
                                        "Flags extended to 64 bits";
                                    }
    
                                    leaf flags {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint16;
                                      description
                                        "Flags";
                                    }
    
                                    leaf private-flags {
                                      type uint16;
                                      description
                                        "Private Flags, used internally by RIB";
                                    }
    
                                    leaf minimum-recurse-length {
                                      type uint8;
                                      description
                                        "Minimum netmask length of recursive resolving
    route";
                                    }
    
                                    leaf looped {
                                      type boolean;
                                      description
                                        "Looping path";
                                    }
    
                                    leaf next-hop-table-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "The table to which the next hop belongs";
                                    }
    
                                    leaf next-hop-vrf-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "VRF Name of the nh table";
                                    }
    
                                    leaf next-hop-table-name {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "NH table name";
                                    }
    
                                    leaf next-hop-afi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH afi";
                                    }
    
                                    leaf next-hop-safi {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NH safi";
                                    }
    
                                    leaf route-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Label associated with this path";
                                    }
    
                                    leaf tunnel-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Tunnel ID associated with this path";
                                    }
    
                                    leaf pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path";
                                    }
    
                                    leaf backup-pathid {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Path id of this path's backup";
                                    }
    
                                    leaf ref-cnt-of-backup {
                                      type uint32;
                                      description
                                        "For backup paths, the number of active paths
    protected by the backup path";
                                    }
    
                                    leaf number-of-extended-communities {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Number of extended communities associated with
    this path";
                                    }
    
                                    leaf mvpn-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "MVPN attribute present";
                                    }
    
                                    leaf path-rt-present {
                                      type boolean;
                                      description
                                        "Path RT present";
                                    }
    
                                    leaf vrf-import-rt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "VRFIMPORTRTPresent";
                                    }
    
                                    leaf source-asrt-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCEASRTPresent";
                                    }
    
                                    leaf source-rd-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "SOURCERDPresent";
                                    }
    
                                    leaf segmented-nexthop-present {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Segmented NH attributes present for this path";
                                    }
    
                                    leaf number-of-nnh {
                                      type uint32;
                                      description
                                        "Number of Next Next Hops";
                                    }
    
                                    leaf next-hop-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "NHID associated with this path";
                                    }
    
                                    leaf next-hop-id-refcount {
                                      type uint32;
                                      description
                                        "NHID references";
                                    }
    
                                    leaf ospf-area-id {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type string;
                                      description
                                        "OSPF area associated with the path";
                                    }
    
                                    leaf has-labelstk {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type boolean;
                                      description
                                        "Path has a label stack";
                                    }
    
                                    leaf num-labels {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint8;
                                      description
                                        "Number of labels in stack";
                                    }
    
                                    leaf binding-label {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "binding Label for this path";
                                    }
    
                                    leaf nhid-feid {
                                      type uint64;
                                      description
                                        "Fib nhid encap id";
                                    }
    
                                    leaf mpls-feid {
                                      type uint64;
                                      description
                                        "Fib mpls encap id";
                                    }
    
                                    leaf has-vxlan-network-id {
                                      type boolean;
                                      description
                                        "VXLAN Network Identifier exists for this path";
                                    }
    
                                    leaf vxlan-network-id {
                                      type uint32;
                                      description
                                        "VXLAN Network Identifier for this path";
                                    }
    
                                    leaf has-xcid {
                                      type boolean;
                                      description
                                        "L2 Cross Connect ID exists for this path";
                                    }
    
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf has-span-diag-interface {
                                      type boolean;
                                      description
                                        "SPAN Diagnostics Interface exists for this path";
                                    }
    
                                    leaf span-diag-interface {
                                      type xr:Interface-name;
                                      description
                                        "SPAN Diagnostics Interface for this path";
                                    }
    
                                    leaf has-subscriber-parent-interface {
                                      type boolean;
                                      description
                                        "Subscriber Parent Interface exists for this
    path";
                                    }
    
                                    leaf subscriber-parent-interface {
                                      type xr:Interface-name;
                                      description
                                        "Subscriber Parent Interface for this path";
                                    }
    
                                    leaf interface-index-present {
                                      type boolean;
                                      description
                                        "Flag to indicate if interface index attribute
    is present for this path";
                                    }
    
                                    leaf interface-index-attribute {
                                      type uint32;
                                      description
                                        "Interface Index attribute";
                                    }
    
                                    leaf iid-present {
                                      type boolean;
                                      description
                                        "Internal ID present";
                                    }
    
                                    leaf iid {
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Internal ID attribute";
                                    }
    
                                    leaf has-l2-info {
                                      type boolean;
                                      description
                                        "L2 Info present for this path";
                                    }
    
                                    list remote-backup-addr {
                                      max-elements
                                        2;
                                      description
                                        "Remote backup node address";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type Ipv4-rib-edm-addr;
                                        description
                                          "Remote backup node address";
                                      }
                                    }  // list remote-backup-addr
    
                                    list labelstk {
                                      description
                                        "Outgoing label stack for this path";
                                      leaf entry {
                                        xr:event-telemetry "Subscribe Telemetry Event";
                                        type uint32;
                                        description
                                          "Outgoing label stack for this path";
                                      }
                                    }  // list labelstk
    
                                    list next-next-hop {
                                      description
                                        "List of Next Next Hops";
                                      leaf type {
                                        type Rib-edm-nnh;
                                        description
                                          "type";
                                      }
    
                                      leaf unknownval {
                                        when
                                          "../type = 'unknown'" {
                                          description
                                            "../type = 'Unknown'";
                                        }
                                        type uint32;
                                        description
                                          "Unknown Value";
                                      }
    
                                      leaf address {
                                        when
                                          "../type = 'ipv4-address'" {
                                          description
                                            "../type = 'IPv4Address'";
                                        }
                                        type inet:ipv4-address;
                                        description
                                          "IPv4 Address";
                                      }
    
                                      leaf interface-index {
                                        when
                                          "../type = 'if-index'" {
                                          description
                                            "../type = 'IfIndex'";
                                        }
                                        type uint32;
                                        description
                                          "Interface Index";
                                      }
                                    }  // list next-next-hop
                                  }  // list ipv4-rib-edm-path
                                }  // container route-path
    
                                leaf prefix {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Route prefix";
                                }
    
                                leaf prefix-length-xr {
                                  type uint8;
                                  description
                                    "Length of prefix";
                                }
    
                                leaf route-version {
                                  type uint32;
                                  description
                                    "Route version, incremented by one on each active
    route change";
                                }
    
                                leaf protocol-id {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Protocol advertising the route";
                                }
    
                                leaf protocol-name {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type string;
                                  description
                                    " Name of Protocol";
                                }
    
                                leaf instance {
                                  type string;
                                  description
                                    "Instance name";
                                }
    
                                leaf client-id {
                                  type uint32;
                                  description
                                    "Client adding the route to RIB";
                                }
    
                                leaf route-type {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint16;
                                  description
                                    "Type of route installed in RIB";
                                }
    
                                leaf priority {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route priority";
                                }
    
                                leaf svd-type {
                                  type uint8;
                                  description
                                    "SVD Type of route";
                                }
    
                                leaf l2-route-type {
                                  type uint8;
                                  description
                                    "Type of route associated with L2 Service";
                                }
    
                                leaf flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route flags";
                                }
    
                                leaf extended-flags {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint64;
                                  description
                                    "Extended Route flags";
                                }
    
                                leaf tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Opaque proto specific info";
                                }
    
                                leaf distance {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Distance of the route";
                                }
    
                                leaf diversion-distance {
                                  type uint32;
                                  description
                                    "Diversion distance of the route";
                                }
    
                                leaf metric {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Route metric";
                                }
    
                                leaf paths-count {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint32;
                                  description
                                    "Number of paths";
                                }
    
                                leaf attribute-identity {
                                  type uint32;
                                  description
                                    "BGP Attribute ID";
                                }
    
                                leaf traffic-index {
                                  type uint8;
                                  description
                                    "BGP Traffic Index";
                                }
    
                                leaf route-precedence {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "IP precedence for this route";
                                }
    
                                leaf qos-group {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Route qos group";
                                }
    
                                leaf flow-tag {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Flow tag for this route";
                                }
    
                                leaf fwd-class {
                                  xr:event-telemetry "Subscribe Telemetry Event";
                                  type uint8;
                                  description
                                    "Forward Class";
                                }
    
                                leaf pic-count {
                                  type uint8;
                                  description
                                    "Number of pic paths in this route";
                                }
    
                                leaf active {
                                  type boolean;
                                  description
                                    "Is the route active or backup";
                                }
    
                                leaf diversion {
                                  type boolean;
                                  description
                                    "Route has a diversion path";
                                }
    
                                leaf diversion-proto-name {
                                  type string;
                                  description
                                    "Diversion route protocol name";
                                }
    
                                leaf route-age {
                                  type uint32;
                                  units "second";
                                  description
                                    "Age of route (seconds)";
                                }
    
                                leaf route-label {
                                  type uint32;
                                  description
                                    "Local label of the route";
                                }
    
                                leaf version {
                                  type uint32;
                                  description
                                    "Route Version";
                                }
    
                                leaf tbl-version {
                                  type uint64;
                                  description
                                    "Table Version";
                                }
    
                                leaf route-modify-time {
                                  type uint64;
                                  units
                                    "nanosecond";
                                  description
                                    "Route modification time(nanoseconds)";
                                }
    
                                leaf prefix-feid {
                                  type uint64;
                                  description
                                    "Fib per-prefix encap id";
                                }
    
                                leaf number-of-algorithm-labels {
                                  type uint16;
                                  description
                                    "Number of Algorithm Labels associated with this
    prefix";
                                }
    
                                list algorithm-label {
                                  description
                                    "List of Algorithm Labels associated with this
    Prefix";
                                  leaf algorithm-id {
                                    type uint8;
                                    description
                                      "Algorithm Identifier";
                                  }
    
                                  leaf label {
                                    type uint32;
                                    description
                                      "Local label";
                                  }
    
                                  leaf metric {
                                    type uint32;
                                    description
                                      "Route Metric associated with Algorithm
    Identifier";
                                  }
                                }  // list algorithm-label
                              }  // container resolved-route
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-len {
                                type uint32;
                                description
                                  "Length of prefix";
                              }
    
                              leaf dest-addr {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Destination address";
                              }
    
                              leaf dest-intf {
                                type uint32;
                                description
                                  "Destination interface";
                              }
    
                              leaf dest-tableid {
                                type uint32;
                                description
                                  "Destination tableid";
                              }
    
                              leaf dest-metric {
                                type uint32;
                                description
                                  "Destination metric";
                              }
    
                              leaf dest-vrf-name {
                                type string;
                                description
                                  "VRF Name of the nh table";
                              }
    
                              leaf damped {
                                type boolean;
                                description
                                  "Nexthop being damped?";
                              }
    
                              leaf exact-match-xr {
                                type boolean;
                                description
                                  "Exact match";
                              }
    
                              leaf allow-default-xr {
                                type boolean;
                                description
                                  "Allow default flag";
                              }
    
                              leaf recurse-xr {
                                type boolean;
                                description
                                  "Allow recurse flag";
                              }
    
                              leaf xtable {
                                type boolean;
                                description
                                  "Cross table nexthop";
                              }
    
                              leaf pack-sf-xr {
                                type boolean;
                                description
                                  "Pack SFS paths for multicast";
                              }
    
                              leaf pack-backup {
                                type boolean;
                                description
                                  "Pack backup paths";
                              }
    
                              leaf backup-route-xr {
                                type boolean;
                                description
                                  "Backup route notifications";
                              }
    
                              leaf best-metric-xr {
                                type boolean;
                                description
                                  "Return lowest metric for dest. metric";
                              }
    
                              leaf unres-nh-tree {
                                type boolean;
                                description
                                  "Context about which tree the server should walk";
                              }
    
                              leaf flags {
                                type uint16;
                                description
                                  "nh_entry flags";
                              }
    
                              leaf dest-path-count {
                                type uint32;
                                description
                                  "Number of destination paths";
                              }
    
                              leaf accrued-penalty {
                                type uint16;
                                description
                                  "Damped accured penalty";
                              }
    
                              leaf expiration-age {
                                type uint32;
                                description
                                  "How soon the nexthop is undamped";
                              }
    
                              leaf expiration-time {
                                type uint64;
                                description
                                  "Time where the first is undamped";
                              }
    
                              leaf min-damped-threshold {
                                type uint32;
                                description
                                  "Minimum damped threshold";
                              }
    
                              leaf max-damped-penalty {
                                type uint32;
                                description
                                  "Maximum damped threshold";
                              }
    
                              leaf decay-rate {
                                type uint32;
                                description
                                  "Damped decay rate";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Event version";
                              }
    
                              leaf last-event-age {
                                type uint32;
                                description
                                  "How long since last event occured";
                              }
    
                              leaf last-event-time {
                                type uint64;
                                description
                                  "Time at which last event occured";
                              }
    
                              list dest-path {
                                description
                                  "Path(s) of the route";
                                leaf interface {
                                  type uint32;
                                  description
                                    "interface";
                                }
    
                                leaf address {
                                  type Ipv4-rib-edm-addr;
                                  description
                                    "Address";
                                }
    
                                leaf tableid {
                                  type uint32;
                                  description
                                    "tableid";
                                }
    
                                leaf vrf-name {
                                  type string;
                                  description
                                    "VRF Name of the nh table";
                                }
                              }  // list dest-path
                            }  // list nexthop
                          }  // container nexthops
    
                          container backup-routes {
                            description
                              "Backup route information for the given
    table";
                            list backup-route {
                              key "address prefix-length protoid";
                              description
                                "Route information for a specific backup
    address ";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Backup network address";
                              }
    
                              leaf prefix-length {
                                type xr:Ipv4-prefix-length;
                                description
                                  "Prefix length of the backup network
    address";
                              }
    
                              leaf protoid {
                                type uint32 {
                                  range "0..96";
                                }
                                description
                                  "Proto ID";
                              }
    
                              container srv6-info {
                                description
                                  "SRv6 related information";
                                container srv6-endpoint-behavior {
                                  description
                                    "SRv6 Endpoint behavior/type";
                                  leaf type {
                                    type Mgmt-srv6-endpoint;
                                    description
                                      "Behavior type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Behavior description";
                                  }
                                }  // container srv6-endpoint-behavior
    
                                container srv6-format {
                                  description
                                    "SRv6 Format";
                                  leaf type {
                                    type Mgmt-srv6-sid-fmt;
                                    description
                                      "Format type";
                                  }
    
                                  leaf description {
                                    type string;
                                    description
                                      "Format description";
                                  }
                                }  // container srv6-format
    
                                leaf is-srv6-endpoint {
                                  type boolean;
                                  description
                                    "Route is an SRv6 Endpoint (local SID)";
                                }
    
                                leaf is-srv6-locator {
                                  type boolean;
                                  description
                                    "Route corresponds to an SRv6 remote locator";
                                }
    
                                leaf srv6-locator-algo {
                                  type uint8;
                                  description
                                    "SRv6 Algo corresponding to SRv6 remote locator";
                                }
                              }  // container srv6-info
    
                              container route-path {
                                description
                                  "Path(s) of the route";
                                list ipv4-rib-edm-path {
                                  description
                                    "Next path";
                                  container l2-info {
                                    description
                                      "L2 Info for this path";
                                    leaf xcid {
                                      type uint32;
                                      description
                                        "L2 Cross Connect ID for this path";
                                    }
    
                                    leaf ac-interface {
                                      type xr:Interface-name;
                                      description
                                        "L2 AC Interface";
                                    }
                                  }  // container l2-info
    
                                  container srv6-info {
                                    description
                                      "SRv6 related information";
                                    container srv6-carrier-format {
                                      description
                                        "SRv6 Carrier Format";
                                      leaf type {
                                        type Mgmt-srv6-sid-fmt;
                                        description
                                          "Format type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Format description";
                                      }
                                    }  // container srv6-carrier-format
    
                                    container srv6-headend-behavior {
                                      description
                                        "SRv6 headend behavior/type info";
                                      leaf type {
                                        type Mgmt-srv6-headend;
                                        description
                                          "Behavior type";
                                      }
    
                                      leaf description {
                                        type string;
                                        description
                                          "Behavior description";
                                      }
                                    }  // container srv6-headend-behavior
    
                                    container via-srv6-sid {
                                      description
                                        "Via-SRv6-SID value";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "Via-SRv6-SID value";
                                      }
    
                                      leaf resolution-length {
                                        type uint8;
                                        description
                                          "FIB Resolution length";
                                      }
                                    }  // container via-srv6-sid
    
                                    leaf number-of-srv6-carriers {
                                      type uint8;
                                      description
                                        "Number of SRv6 Carriers";
                                    }
    
                                    leaf has-srv6-headend-behavior {
                                      type boolean;
                                      description
                                        "Path has some SRv6 head-end behavior associated";
                                    }
    
                                    leaf has-via-srv6-sid {
                                      type boolean;
                                      description
                                        "Via-SRv6-SID is present";
                                    }
    
                                    list srv6-carrier {
                                      description
                                        "List of SRv6 Carriers with one or more SIDs";
                                      leaf sid {
                                        type inet:ipv6-address;
                                        description
                                          "SID value";
                                      }
                                    }  // list srv6-carrier
                                  }  // container srv6-info
    
                                  leaf address {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Nexthop";
                                  }
    
                                  leaf information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Infosource";
                                  }
    
                                  leaf v6-nexthop {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 nexthop for v4 over v6";
                                  }
    
                                  leaf v6-information-source {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type inet:ipv6-address;
                                    description
                                      "V6 Infosource";
                                  }
    
                                  leaf interface-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type xr:Interface-name;
                                    description
                                      "Interface handle for the path's nexthop";
                                  }
    
                                  leaf metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Metrics";
                                  }
    
                                  leaf load-metric {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Load Metrics";
                                  }
    
                                  leaf flags64 {
                                    type uint64;
                                    description
                                      "Flags extended to 64 bits";
                                  }
    
                                  leaf flags {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint16;
                                    description
                                      "Flags";
                                  }
    
                                  leaf private-flags {
                                    type uint16;
                                    description
                                      "Private Flags, used internally by RIB";
                                  }
    
                                  leaf minimum-recurse-length {
                                    type uint8;
                                    description
                                      "Minimum netmask length of recursive resolving
    route";
                                  }
    
                                  leaf looped {
                                    type boolean;
                                    description
                                      "Looping path";
                                  }
    
                                  leaf next-hop-table-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "The table to which the next hop belongs";
                                  }
    
                                  leaf next-hop-vrf-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "VRF Name of the nh table";
                                  }
    
                                  leaf next-hop-table-name {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "NH table name";
                                  }
    
                                  leaf next-hop-afi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH afi";
                                  }
    
                                  leaf next-hop-safi {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NH safi";
                                  }
    
                                  leaf route-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Label associated with this path";
                                  }
    
                                  leaf tunnel-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Tunnel ID associated with this path";
                                  }
    
                                  leaf pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path";
                                  }
    
                                  leaf backup-pathid {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Path id of this path's backup";
                                  }
    
                                  leaf ref-cnt-of-backup {
                                    type uint32;
                                    description
                                      "For backup paths, the number of active paths
    protected by the backup path";
                                  }
    
                                  leaf number-of-extended-communities {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "Number of extended communities associated with
    this path";
                                  }
    
                                  leaf mvpn-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "MVPN attribute present";
                                  }
    
                                  leaf path-rt-present {
                                    type boolean;
                                    description
                                      "Path RT present";
                                  }
    
                                  leaf vrf-import-rt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "VRFIMPORTRTPresent";
                                  }
    
                                  leaf source-asrt-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCEASRTPresent";
                                  }
    
                                  leaf source-rd-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "SOURCERDPresent";
                                  }
    
                                  leaf segmented-nexthop-present {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Segmented NH attributes present for this path";
                                  }
    
                                  leaf number-of-nnh {
                                    type uint32;
                                    description
                                      "Number of Next Next Hops";
                                  }
    
                                  leaf next-hop-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "NHID associated with this path";
                                  }
    
                                  leaf next-hop-id-refcount {
                                    type uint32;
                                    description
                                      "NHID references";
                                  }
    
                                  leaf ospf-area-id {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type string;
                                    description
                                      "OSPF area associated with the path";
                                  }
    
                                  leaf has-labelstk {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type boolean;
                                    description
                                      "Path has a label stack";
                                  }
    
                                  leaf num-labels {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint8;
                                    description
                                      "Number of labels in stack";
                                  }
    
                                  leaf binding-label {
                                    xr:event-telemetry "Subscribe Telemetry Event";
                                    type uint32;
                                    description
                                      "binding Label for this path";
                                  }
    
                                  leaf nhid-feid {
                                    type uint64;
                                    description
                                      "Fib nhid encap id";
                                  }
    
                                  leaf mpls-feid {
                                    type uint64;
                                    description
                                      "Fib mpls encap id";
                                  }
    
                                  leaf has-vxlan-network-id {
                                    type boolean;
                                    description
                                      "VXLAN Network Identifier exists for this path";
                                  }
    
                                  leaf vxlan-network-id {
                                    type uint32;
                                    description
                                      "VXLAN Network Identifier for this path";
                                  }
    
                                  leaf has-xcid {
                                    type boolean;
                                    description
                                      "L2 Cross Connect ID exists for this path";
                                  }
    
                                  leaf xcid {
                                    type uint32;
                                    description
                                      "L2 Cross Connect ID for this path";
                                  }
    
                                  leaf has-span-diag-interface {
                                    type boolean;
                                    description
                                      "SPAN Diagnostics Interface exists for this path";
                                  }
    
                                  leaf span-diag-interface {
                                    type xr:Interface-name;
                                    description
                                      "SPAN Diagnostics Interface for this path";
                                  }
    
                                  leaf has-subscriber-parent-interface {
                                    type boolean;
                                    description
                                      "Subscriber Parent Interface exists for this
    path";
                                  }
    
                                  leaf subscriber-parent-interface {
                                    type xr:Interface-name;
                                    description
                                      "Subscriber Parent Interface for this path";
                                  }
    
                                  leaf interface-index-present {
                                    type boolean;
                                    description
                                      "Flag to indicate if interface index attribute
    is present for this path";
                                  }
    
                                  leaf interface-index-attribute {
                                    type uint32;
                                    description
                                      "Interface Index attribute";
                                  }
    
                                  leaf iid-present {
                                    type boolean;
                                    description
                                      "Internal ID present";
                                  }
    
                                  leaf iid {
                                    type Ipv4-rib-edm-addr;
                                    description
                                      "Internal ID attribute";
                                  }
    
                                  leaf has-l2-info {
                                    type boolean;
                                    description
                                      "L2 Info present for this path";
                                  }
    
                                  list remote-backup-addr {
                                    max-elements
                                      2;
                                    description
                                      "Remote backup node address";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type Ipv4-rib-edm-addr;
                                      description
                                        "Remote backup node address";
                                    }
                                  }  // list remote-backup-addr
    
                                  list labelstk {
                                    description
                                      "Outgoing label stack for this path";
                                    leaf entry {
                                      xr:event-telemetry "Subscribe Telemetry Event";
                                      type uint32;
                                      description
                                        "Outgoing label stack for this path";
                                    }
                                  }  // list labelstk
    
                                  list next-next-hop {
                                    description
                                      "List of Next Next Hops";
                                    leaf type {
                                      type Rib-edm-nnh;
                                      description
                                        "type";
                                    }
    
                                    leaf unknownval {
                                      when
                                        "../type = 'unknown'" {
                                        description
                                          "../type = 'Unknown'";
                                      }
                                      type uint32;
                                      description
                                        "Unknown Value";
                                    }
    
                                    leaf address {
                                      when
                                        "../type = 'ipv4-address'" {
                                        description
                                          "../type = 'IPv4Address'";
                                      }
                                      type inet:ipv4-address;
                                      description
                                        "IPv4 Address";
                                    }
    
                                    leaf interface-index {
                                      when
                                        "../type = 'if-index'" {
                                        description
                                          "../type = 'IfIndex'";
                                      }
                                      type uint32;
                                      description
                                        "Interface Index";
                                    }
                                  }  // list next-next-hop
                                }  // list ipv4-rib-edm-path
                              }  // container route-path
    
                              leaf prefix {
                                type Ipv4-rib-edm-addr;
                                description
                                  "Route prefix";
                              }
    
                              leaf prefix-length-xr {
                                type uint8;
                                description
                                  "Length of prefix";
                              }
    
                              leaf route-version {
                                type uint32;
                                description
                                  "Route version, incremented by one on each active
    route change";
                              }
    
                              leaf protocol-id {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Protocol advertising the route";
                              }
    
                              leaf protocol-name {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type string;
                                description
                                  " Name of Protocol";
                              }
    
                              leaf instance {
                                type string;
                                description
                                  "Instance name";
                              }
    
                              leaf client-id {
                                type uint32;
                                description
                                  "Client adding the route to RIB";
                              }
    
                              leaf route-type {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint16;
                                description
                                  "Type of route installed in RIB";
                              }
    
                              leaf priority {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route priority";
                              }
    
                              leaf svd-type {
                                type uint8;
                                description
                                  "SVD Type of route";
                              }
    
                              leaf l2-route-type {
                                type uint8;
                                description
                                  "Type of route associated with L2 Service";
                              }
    
                              leaf flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route flags";
                              }
    
                              leaf extended-flags {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint64;
                                description
                                  "Extended Route flags";
                              }
    
                              leaf tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Opaque proto specific info";
                              }
    
                              leaf distance {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Distance of the route";
                              }
    
                              leaf diversion-distance {
                                type uint32;
                                description
                                  "Diversion distance of the route";
                              }
    
                              leaf metric {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Route metric";
                              }
    
                              leaf paths-count {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Number of paths";
                              }
    
                              leaf attribute-identity {
                                type uint32;
                                description
                                  "BGP Attribute ID";
                              }
    
                              leaf traffic-index {
                                type uint8;
                                description
                                  "BGP Traffic Index";
                              }
    
                              leaf route-precedence {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "IP precedence for this route";
                              }
    
                              leaf qos-group {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Route qos group";
                              }
    
                              leaf flow-tag {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Flow tag for this route";
                              }
    
                              leaf fwd-class {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint8;
                                description
                                  "Forward Class";
                              }
    
                              leaf pic-count {
                                type uint8;
                                description
                                  "Number of pic paths in this route";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Is the route active or backup";
                              }
    
                              leaf diversion {
                                type boolean;
                                description
                                  "Route has a diversion path";
                              }
    
                              leaf diversion-proto-name {
                                type string;
                                description
                                  "Diversion route protocol name";
                              }
    
                              leaf route-age {
                                type uint32;
                                units "second";
                                description
                                  "Age of route (seconds)";
                              }
    
                              leaf route-label {
                                type uint32;
                                description
                                  "Local label of the route";
                              }
    
                              leaf version {
                                type uint32;
                                description
                                  "Route Version";
                              }
    
                              leaf tbl-version {
                                type uint64;
                                description
                                  "Table Version";
                              }
    
                              leaf route-modify-time {
                                type uint64;
                                units
                                  "nanosecond";
                                description
                                  "Route modification time(nanoseconds)";
                              }
    
                              leaf prefix-feid {
                                type uint64;
                                description
                                  "Fib per-prefix encap id";
                              }
    
                              leaf number-of-algorithm-labels {
                                type uint16;
                                description
                                  "Number of Algorithm Labels associated with this
    prefix";
                              }
    
                              list algorithm-label {
                                description
                                  "List of Algorithm Labels associated with this
    Prefix";
                                leaf algorithm-id {
                                  type uint8;
                                  description
                                    "Algorithm Identifier";
                                }
    
                                leaf label {
                                  type uint32;
                                  description
                                    "Local label";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Route Metric associated with Algorithm
    Identifier";
                                }
                              }  // list algorithm-label
                            }  // list backup-route
                          }  // container backup-routes
    
                          container adverts-list {
                            description
                              "Route advertiser information ";
                            container advert-prefixes {
                              description
                                "Route advertiser prefix table";
                              list advert-prefix {
                                key "address prefix-length";
                                description
                                  "Route advertiser information of a
    specific Network Address ";
                                container adverts {
                                  description
                                    "Route advertiser table";
                                  list advert {
                                    key "protoid";
                                    description
                                      "Route advertiser information of a
    specific Network Address and Client";
                                    leaf protoid {
                                      type uint32 {
                                        range
                                          "0..96";
                                      }
                                      description
                                        "Proto ID";
                                    }
    
                                    list ipv4-rib-edm-advert {
                                      description
                                        "Next advertising proto";
                                      leaf protocol-id {
                                        type uint32;
                                        description
                                          "Protocol advertising the route";
                                      }
    
                                      leaf client-id {
                                        type uint32;
                                        description
                                          "  Client advertising the route";
                                      }
    
                                      leaf number-of-extended-communities {
                                        type uint32;
                                        description
                                          "Number of extended communities attached by
    advertiser";
                                      }
    
                                      leaf extended-communities {
                                        type yang:hex-string;
                                        description
                                          "Extended communities attached by the advertiser";
                                      }
    
                                      leaf protocol-opaque-flags {
                                        type uint8;
                                        description
                                          "OSPF area-id flags";
                                      }
    
                                      leaf protocol-opaque {
                                        type uint32;
                                        description
                                          "OSPF area-id";
                                      }
    
                                      leaf code {
                                        type int8;
                                        description
                                          "Protocol code";
                                      }
    
                                      leaf instance-name {
                                        type string {
                                          length
                                            "0..41";
                                        }
                                        description
                                          "Instance name of the protocol advertising the
    route";
                                      }
                                    }  // list ipv4-rib-edm-advert
                                  }  // list advert
                                }  // container adverts
    
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "Network Address";
                                }
    
                                leaf prefix-length {
                                  type xr:Ipv4-prefix-length;
                                  description
                                    "Prefix length of the network address";
                                }
                              }  // list advert-prefix
                            }  // container advert-prefixes
                          }  // container adverts-list
    
                          leaf route-table-name {
                            type xr:Cisco-ios-xr-string;
                            description
                              "Name of the route table";
                          }
                        }  // list ip-rib-route-table-name
                      }  // container ip-rib-route-table-names
    
                      leaf saf-name {
                        type Rib-saf-name;
                        description
                          "Name of the SAF";
                      }
                    }  // list saf
                  }  // container safs
    
                  leaf af-name {
                    type Rib-af-name;
                    description "Name of the AF";
                  }
                }  // list af
              }  // container afs
    
              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description "Name of the VRF";
              }
            }  // list vrf
          }  // container vrfs
    
          container rib-table-ids {
            description "RIB table";
            list rib-table-id {
              key "tableid";
              description "Specific Table";
              container summary-protos {
                description "RIB table summary";
                list summary-proto {
                  key "protoid";
                  description
                    "Route summary information for a specific
    table/protocol ";
                  leaf protoid {
                    type uint32 {
                      range "0..96";
                    }
                    description "Proto ID";
                  }
    
                  container proto-route-count {
                    description
                      "Count for proto. instance";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container proto-route-count
    
                  container rtype-none {
                    description "No route type";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-none
    
                  container rtype-other {
                    description
                      "Unknown route type";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-other
    
                  container rtype-ospf-intra {
                    description
                      "OSPF route within an area";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-intra
    
                  container rtype-ospf-inter {
                    description
                      "OSPF route across diff. areas";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-inter
    
                  container rtype-ospf-extern1 {
                    description
                      "OSPF external route of type 1";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-extern1
    
                  container rtype-ospf-extern2 {
                    description
                      "OSPF external route of type 2";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-extern2
    
                  container rtype-isis-sum {
                    description
                      "IS-IS summary route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-sum
    
                  container rtype-isis-l1 {
                    description
                      "IS-IS level 1 route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l1
    
                  container rtype-isis-l2 {
                    description
                      "IS-IS level 2 route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l2
    
                  container rtype-isis-l1-ia {
                    description
                      "IS-IS level1 inter-area route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-isis-l1-ia
    
                  container rtype-bgp-int {
                    description "iBGP route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-int
    
                  container rtype-bgp-ext {
                    description "eBGP route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-ext
    
                  container rtype-bgp-loc {
                    description
                      "BGP local route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-bgp-loc
    
                  container rtype-ospf-nssa1 {
                    description
                      "OSPF NSSA ext. route type 1";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-nssa1
    
                  container rtype-ospf-nssa2 {
                    description
                      "OSPF NSSA ext. route type 2";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-ospf-nssa2
    
                  container rtype-igrp2-int {
                    description
                      "EIGRP internal route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-igrp2-int
    
                  container rtype-igrp2-ext {
                    description
                      "EIGRP external route";
                    leaf active-routes-count {
                      type uint32;
                      description
                        "Number of active routes";
                    }
    
                    leaf num-backup-routes {
                      type uint32;
                      description
                        "Number of backup (inactive) routes";
                    }
    
                    leaf num-active-paths {
                      type uint32;
                      description
                        "Number of paths to active routes";
                    }
    
                    leaf num-backup-paths {
                      type uint32;
                      description
                        "Number of paths to backup routes";
                    }
                  }  // container rtype-igrp2-ext
    
                  leaf name {
                    type string;
                    description "Proto name";
                  }
    
                  leaf instance {
                    type string;
                    description
                      "Instance name of the protocol";
                  }
                }  // list summary-proto
              }  // container summary-protos
    
              container rib-table-itf-hndls {
                description
                  "RIB table interface";
                list rib-table-itf-hndl {
                  key "handle";
                  description "Interface handle";
                  leaf handle {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description "Itf Handle";
                  }
    
                  list itf-route {
                    key "address";
                    description
                      "Route information for a specific
    table/interface ";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "Network Address";
                    }
    
                    container srv6-info {
                      description
                        "SRv6 related information";
                      container srv6-endpoint-behavior {
                        description
                          "SRv6 Endpoint behavior/type";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }
    
                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-endpoint-behavior
    
                      container srv6-format {
                        description
                          "SRv6 Format";
                        leaf type {
                          type Mgmt-srv6-sid-fmt;
                          description
                            "Format type";
                        }
    
                        leaf description {
                          type string;
                          description
                            "Format description";
                        }
                      }  // container srv6-format
    
                      leaf is-srv6-endpoint {
                        type boolean;
                        description
                          "Route is an SRv6 Endpoint (local SID)";
                      }
    
                      leaf is-srv6-locator {
                        type boolean;
                        description
                          "Route corresponds to an SRv6 remote locator";
                      }
    
                      leaf srv6-locator-algo {
                        type uint8;
                        description
                          "SRv6 Algo corresponding to SRv6 remote locator";
                      }
                    }  // container srv6-info
    
                    container route-path {
                      description
                        "Path(s) of the route";
                      list ipv4-rib-edm-path {
                        description "Next path";
                        container l2-info {
                          description
                            "L2 Info for this path";
                          leaf xcid {
                            type uint32;
                            description
                              "L2 Cross Connect ID for this path";
                          }
    
                          leaf ac-interface {
                            type xr:Interface-name;
                            description
                              "L2 AC Interface";
                          }
                        }  // container l2-info
    
                        container srv6-info {
                          description
                            "SRv6 related information";
                          container srv6-carrier-format {
                            description
                              "SRv6 Carrier Format";
                            leaf type {
                              type Mgmt-srv6-sid-fmt;
                              description
                                "Format type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Format description";
                            }
                          }  // container srv6-carrier-format
    
                          container srv6-headend-behavior {
                            description
                              "SRv6 headend behavior/type info";
                            leaf type {
                              type Mgmt-srv6-headend;
                              description
                                "Behavior type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-headend-behavior
    
                          container via-srv6-sid {
                            description
                              "Via-SRv6-SID value";
                            leaf sid {
                              type inet:ipv6-address;
                              description
                                "Via-SRv6-SID value";
                            }
    
                            leaf resolution-length {
                              type uint8;
                              description
                                "FIB Resolution length";
                            }
                          }  // container via-srv6-sid
    
                          leaf number-of-srv6-carriers {
                            type uint8;
                            description
                              "Number of SRv6 Carriers";
                          }
    
                          leaf has-srv6-headend-behavior {
                            type boolean;
                            description
                              "Path has some SRv6 head-end behavior associated";
                          }
    
                          leaf has-via-srv6-sid {
                            type boolean;
                            description
                              "Via-SRv6-SID is present";
                          }
    
                          list srv6-carrier {
                            description
                              "List of SRv6 Carriers with one or more SIDs";
                            leaf sid {
                              type inet:ipv6-address;
                              description
                                "SID value";
                            }
                          }  // list srv6-carrier
                        }  // container srv6-info
    
                        leaf address {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type Ipv4-rib-edm-addr;
                          description "Nexthop";
                        }
    
                        leaf information-source {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type Ipv4-rib-edm-addr;
                          description
                            "Infosource";
                        }
    
                        leaf v6-nexthop {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type inet:ipv6-address;
                          description
                            "IPv6 nexthop for v4 over v6";
                        }
    
                        leaf v6-information-source {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type inet:ipv6-address;
                          description
                            "V6 Infosource";
                        }
    
                        leaf interface-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type xr:Interface-name;
                          description
                            "Interface handle for the path's nexthop";
                        }
    
                        leaf metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "Metrics";
                        }
    
                        leaf load-metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Load Metrics";
                        }
    
                        leaf flags64 {
                          type uint64;
                          description
                            "Flags extended to 64 bits";
                        }
    
                        leaf flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint16;
                          description "Flags";
                        }
    
                        leaf private-flags {
                          type uint16;
                          description
                            "Private Flags, used internally by RIB";
                        }
    
                        leaf minimum-recurse-length {
                          type uint8;
                          description
                            "Minimum netmask length of recursive resolving
    route";
                        }
    
                        leaf looped {
                          type boolean;
                          description
                            "Looping path";
                        }
    
                        leaf next-hop-table-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "The table to which the next hop belongs";
                        }
    
                        leaf next-hop-vrf-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "VRF Name of the nh table";
                        }
    
                        leaf next-hop-table-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "NH table name";
                        }
    
                        leaf next-hop-afi {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "NH afi";
                        }
    
                        leaf next-hop-safi {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description "NH safi";
                        }
    
                        leaf route-label {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Label associated with this path";
                        }
    
                        leaf tunnel-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Tunnel ID associated with this path";
                        }
    
                        leaf pathid {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Path id of this path";
                        }
    
                        leaf backup-pathid {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Path id of this path's backup";
                        }
    
                        leaf ref-cnt-of-backup {
                          type uint32;
                          description
                            "For backup paths, the number of active paths
    protected by the backup path";
                        }
    
                        leaf number-of-extended-communities {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Number of extended communities associated with
    this path";
                        }
    
                        leaf mvpn-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "MVPN attribute present";
                        }
    
                        leaf path-rt-present {
                          type boolean;
                          description
                            "Path RT present";
                        }
    
                        leaf vrf-import-rt-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "VRFIMPORTRTPresent";
                        }
    
                        leaf source-asrt-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "SOURCEASRTPresent";
                        }
    
                        leaf source-rd-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "SOURCERDPresent";
                        }
    
                        leaf segmented-nexthop-present {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "Segmented NH attributes present for this path";
                        }
    
                        leaf number-of-nnh {
                          type uint32;
                          description
                            "Number of Next Next Hops";
                        }
    
                        leaf next-hop-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "NHID associated with this path";
                        }
    
                        leaf next-hop-id-refcount {
                          type uint32;
                          description
                            "NHID references";
                        }
    
                        leaf ospf-area-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            "OSPF area associated with the path";
                        }
    
                        leaf has-labelstk {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type boolean;
                          description
                            "Path has a label stack";
                        }
    
                        leaf num-labels {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Number of labels in stack";
                        }
    
                        leaf binding-label {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "binding Label for this path";
                        }
    
                        leaf nhid-feid {
                          type uint64;
                          description
                            "Fib nhid encap id";
                        }
    
                        leaf mpls-feid {
                          type uint64;
                          description
                            "Fib mpls encap id";
                        }
    
                        leaf has-vxlan-network-id {
                          type boolean;
                          description
                            "VXLAN Network Identifier exists for this path";
                        }
    
                        leaf vxlan-network-id {
                          type uint32;
                          description
                            "VXLAN Network Identifier for this path";
                        }
    
                        leaf has-xcid {
                          type boolean;
                          description
                            "L2 Cross Connect ID exists for this path";
                        }
    
                        leaf xcid {
                          type uint32;
                          description
                            "L2 Cross Connect ID for this path";
                        }
    
                        leaf has-span-diag-interface {
                          type boolean;
                          description
                            "SPAN Diagnostics Interface exists for this path";
                        }
    
                        leaf span-diag-interface {
                          type xr:Interface-name;
                          description
                            "SPAN Diagnostics Interface for this path";
                        }
    
                        leaf has-subscriber-parent-interface {
                          type boolean;
                          description
                            "Subscriber Parent Interface exists for this
    path";
                        }
    
                        leaf subscriber-parent-interface {
                          type xr:Interface-name;
                          description
                            "Subscriber Parent Interface for this path";
                        }
    
                        leaf interface-index-present {
                          type boolean;
                          description
                            "Flag to indicate if interface index attribute
    is present for this path";
                        }
    
                        leaf interface-index-attribute {
                          type uint32;
                          description
                            "Interface Index attribute";
                        }
    
                        leaf iid-present {
                          type boolean;
                          description
                            "Internal ID present";
                        }
    
                        leaf iid {
                          type Ipv4-rib-edm-addr;
                          description
                            "Internal ID attribute";
                        }
    
                        leaf has-l2-info {
                          type boolean;
                          description
                            "L2 Info present for this path";
                        }
    
                        list remote-backup-addr {
                          max-elements 2;
                          description
                            "Remote backup node address";
                          leaf entry {
                            xr:event-telemetry "Subscribe Telemetry Event";
                            type Ipv4-rib-edm-addr;
                            description
                              "Remote backup node address";
                          }
                        }  // list remote-backup-addr
    
                        list labelstk {
                          description
                            "Outgoing label stack for this path";
                          leaf entry {
                            xr:event-telemetry "Subscribe Telemetry Event";
                            type uint32;
                            description
                              "Outgoing label stack for this path";
                          }
                        }  // list labelstk
    
                        list next-next-hop {
                          description
                            "List of Next Next Hops";
                          leaf type {
                            type Rib-edm-nnh;
                            description "type";
                          }
    
                          leaf unknownval {
                            when
                              "../type = 'unknown'" {
                              description
                                "../type = 'Unknown'";
                            }
                            type uint32;
                            description
                              "Unknown Value";
                          }
    
                          leaf address {
                            when
                              "../type = 'ipv4-address'" {
                              description
                                "../type = 'IPv4Address'";
                            }
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }
    
                          leaf interface-index {
                            when
                              "../type = 'if-index'" {
                              description
                                "../type = 'IfIndex'";
                            }
                            type uint32;
                            description
                              "Interface Index";
                          }
                        }  // list next-next-hop
                      }  // list ipv4-rib-edm-path
                    }  // container route-path
    
                    leaf prefix {
                      type Ipv4-rib-edm-addr;
                      description "Route prefix";
                    }
    
                    leaf prefix-length-xr {
                      type uint8;
                      description
                        "Length of prefix";
                    }
    
                    leaf route-version {
                      type uint32;
                      description
                        "Route version, incremented by one on each active
    route change";
                    }
    
                    leaf protocol-id {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Protocol advertising the route";
                    }
    
                    leaf protocol-name {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type string;
                      description
                        " Name of Protocol";
                    }
    
                    leaf instance {
                      type string;
                      description
                        "Instance name";
                    }
    
                    leaf client-id {
                      type uint32;
                      description
                        "Client adding the route to RIB";
                    }
    
                    leaf route-type {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint16;
                      description
                        "Type of route installed in RIB";
                    }
    
                    leaf priority {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Route priority";
                    }
    
                    leaf svd-type {
                      type uint8;
                      description
                        "SVD Type of route";
                    }
    
                    leaf l2-route-type {
                      type uint8;
                      description
                        "Type of route associated with L2 Service";
                    }
    
                    leaf flags {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description "Route flags";
                    }
    
                    leaf extended-flags {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint64;
                      description
                        "Extended Route flags";
                    }
    
                    leaf tag {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Opaque proto specific info";
                    }
    
                    leaf distance {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Distance of the route";
                    }
    
                    leaf diversion-distance {
                      type uint32;
                      description
                        "Diversion distance of the route";
                    }
    
                    leaf metric {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description "Route metric";
                    }
    
                    leaf paths-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Number of paths";
                    }
    
                    leaf attribute-identity {
                      type uint32;
                      description
                        "BGP Attribute ID";
                    }
    
                    leaf traffic-index {
                      type uint8;
                      description
                        "BGP Traffic Index";
                    }
    
                    leaf route-precedence {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "IP precedence for this route";
                    }
    
                    leaf qos-group {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Route qos group";
                    }
    
                    leaf flow-tag {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Flow tag for this route";
                    }
    
                    leaf fwd-class {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint8;
                      description
                        "Forward Class";
                    }
    
                    leaf pic-count {
                      type uint8;
                      description
                        "Number of pic paths in this route";
                    }
    
                    leaf active {
                      type boolean;
                      description
                        "Is the route active or backup";
                    }
    
                    leaf diversion {
                      type boolean;
                      description
                        "Route has a diversion path";
                    }
    
                    leaf diversion-proto-name {
                      type string;
                      description
                        "Diversion route protocol name";
                    }
    
                    leaf route-age {
                      type uint32;
                      units "second";
                      description
                        "Age of route (seconds)";
                    }
    
                    leaf route-label {
                      type uint32;
                      description
                        "Local label of the route";
                    }
    
                    leaf version {
                      type uint32;
                      description
                        "Route Version";
                    }
    
                    leaf tbl-version {
                      type uint64;
                      description
                        "Table Version";
                    }
    
                    leaf route-modify-time {
                      type uint64;
                      units "nanosecond";
                      description
                        "Route modification time(nanoseconds)";
                    }
    
                    leaf prefix-feid {
                      type uint64;
                      description
                        "Fib per-prefix encap id";
                    }
    
                    leaf number-of-algorithm-labels {
                      type uint16;
                      description
                        "Number of Algorithm Labels associated with this
    prefix";
                    }
    
                    list algorithm-label {
                      description
                        "List of Algorithm Labels associated with this
    Prefix";
                      leaf algorithm-id {
                        type uint8;
                        description
                          "Algorithm Identifier";
                      }
    
                      leaf label {
                        type uint32;
                        description
                          "Local label";
                      }
    
                      leaf metric {
                        type uint32;
                        description
                          "Route Metric associated with Algorithm
    Identifier";
                      }
                    }  // list algorithm-label
                  }  // list itf-route
                }  // list rib-table-itf-hndl
              }  // container rib-table-itf-hndls
    
              container information {
                description
                  "Table related Information";
                leaf tableid {
                  type uint32;
                  description "Table id";
                }
    
                leaf afi {
                  type uint32;
                  description "Address Family";
                }
    
                leaf safi {
                  type uint32;
                  description
                    "sub Address Family";
                }
    
                leaf vrf-name {
                  type string;
                  description
                    "VRF Name of the table";
                }
    
                leaf table-name {
                  type string;
                  description
                    "Name of the table";
                }
    
                leaf version {
                  type uint64;
                  description "Table version";
                }
    
                leaf conf-prefix-limit {
                  type uint32;
                  description
                    "Configured prefix limit";
                }
    
                leaf current-prefix-count {
                  type uint32;
                  description
                    "Num prefixes in table";
                }
    
                leaf num-svdlcl-prefix {
                  type uint32;
                  description
                    "Num SVD local prefixes";
                }
    
                leaf num-svdrem-prefix {
                  type uint32;
                  description
                    "Num SVD remote prefixes";
                }
    
                leaf table-version {
                  type uint64;
                  description
                    "Version no. of the table";
                }
    
                leaf prefix-limit-notified {
                  type boolean;
                  description
                    "Prefix limit state indicator";
                }
    
                leaf fwd-referenced {
                  type boolean;
                  description
                    "Table in fwd reference state?";
                }
    
                leaf deleted {
                  type boolean;
                  description "Table deleted?";
                }
    
                leaf initial-converge {
                  type boolean;
                  description
                    "Table has reached convergence";
                }
              }  // container information
    
              container rib-nexthop-prefixes {
                description
                  "RIB table nexthop client table";
                list rib-nexthop-prefix {
                  description
                    "Route address, Prefix length";
                  container rib-nexthop-routes {
                    description
                      "Nexthop route table";
                    list rib-nexthop-route {
                      description
                        "Route information for a specific
    table/interface";
                      leaf exact-match {
                        type boolean;
                        description
                          "Exact Match";
                      }
    
                      leaf allow-default {
                        type boolean;
                        description
                          "Allow Default";
                      }
    
                      leaf recurse {
                        type boolean;
                        description "Recurse";
                      }
    
                      leaf cross-table {
                        type boolean;
                        description
                          "Cross table nextHop";
                      }
    
                      leaf pack-sfs {
                        type boolean;
                        description
                          "Pack SFS paths for Multicast";
                      }
    
                      leaf pack-backup-paths {
                        type boolean;
                        description
                          "Pack backup paths";
                      }
    
                      leaf backup-route {
                        type boolean;
                        description
                          "Backup route notifications";
                      }
    
                      leaf best-metric {
                        type boolean;
                        description
                          "Return lowest metric";
                      }
    
                      container clients {
                        description
                          "Client(s) of the address";
                        list rib-edm-nh-client {
                          description
                            "Next client";
                          leaf id {
                            type uint32;
                            description
                              "Client id";
                          }
    
                          leaf ref-count {
                            type uint32;
                            description
                              "The number NH reference this client";
                          }
    
                          leaf nh-create-age {
                            type uint32;
                            description
                              "How long has client has been created";
                          }
    
                          leaf nh-create-time {
                            type uint64;
                            description
                              "Client creation time";
                          }
    
                          leaf nh-read-age {
                            type uint32;
                            description
                              "How long ago client read this notification";
                          }
    
                          leaf nh-read-time {
                            type uint64;
                            description
                              "Client notification read time";
                          }
    
                          leaf pack-mvpn {
                            type boolean;
                            description
                              "Pack MVPN";
                          }
    
                          leaf pack-path-rt {
                            type boolean;
                            description
                              "Pack path RT";
                          }
    
                          leaf pack-vrf-import-rt {
                            type boolean;
                            description
                              "Pack VRF import RT";
                          }
    
                          leaf pack-source-as-rt {
                            type boolean;
                            description
                              "Pack source AS RT";
                          }
    
                          leaf pack-source-rd {
                            type boolean;
                            description
                              "Pack source RD";
                          }
    
                          leaf pack-mldp-root {
                            type boolean;
                            description
                              "Pack MLDP root";
                          }
    
                          leaf pack-seg-nh {
                            type boolean;
                            description
                              "Pack seg NH";
                          }
    
                          leaf notify-reregister {
                            type boolean;
                            description
                              "Notify Reregister";
                          }
                        }  // list rib-edm-nh-client
                      }  // container clients
    
                      container resolved-route {
                        description
                          "Route resolved this nexthop";
                        container srv6-info {
                          description
                            "SRv6 related information";
                          container srv6-endpoint-behavior {
                            description
                              "SRv6 Endpoint behavior/type";
                            leaf type {
                              type Mgmt-srv6-endpoint;
                              description
                                "Behavior type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-endpoint-behavior
    
                          container srv6-format {
                            description
                              "SRv6 Format";
                            leaf type {
                              type Mgmt-srv6-sid-fmt;
                              description
                                "Format type";
                            }
    
                            leaf description {
                              type string;
                              description
                                "Format description";
                            }
                          }  // container srv6-format
    
                          leaf is-srv6-endpoint {
                            type boolean;
                            description
                              "Route is an SRv6 Endpoint (local SID)";
                          }
    
                          leaf is-srv6-locator {
                            type boolean;
                            description
                              "Route corresponds to an SRv6 remote locator";
                          }
    
                          leaf srv6-locator-algo {
                            type uint8;
                            description
                              "SRv6 Algo corresponding to SRv6 remote locator";
                          }
                        }  // container srv6-info
    
                        container route-path {
                          description
                            "Path(s) of the route";
                          list ipv4-rib-edm-path {
                            description
                              "Next path";
                            container l2-info {
                              description
                                "L2 Info for this path";
                              leaf xcid {
                                type uint32;
                                description
                                  "L2 Cross Connect ID for this path";
                              }
    
                              leaf ac-interface {
                                type xr:Interface-name;
                                description
                                  "L2 AC Interface";
                              }
                            }  // container l2-info
    
                            container srv6-info {
                              description
                                "SRv6 related information";
                              container srv6-carrier-format {
                                description
                                  "SRv6 Carrier Format";
                                leaf type {
                                  type Mgmt-srv6-sid-fmt;
                                  description
                                    "Format type";
                                }
    
                                leaf description {
                                  type string;
                                  description
                                    "Format description";
                                }
                              }  // container srv6-carrier-format
    
                              container srv6-headend-behavior {
                                description
                                  "SRv6 headend behavior/type info";
                                leaf type {
                                  type Mgmt-srv6-headend;
                                  description
                                    "Behavior type";
                                }
    
                                leaf description {
                                  type string;
                                  description
                                    "Behavior description";
                                }
                              }  // container srv6-headend-behavior
    
                              container via-srv6-sid {
                                description
                                  "Via-SRv6-SID value";
                                leaf sid {
                                  type inet:ipv6-address;
                                  description
                                    "Via-SRv6-SID value";
                                }
    
                                leaf resolution-length {
                                  type uint8;
                                  description
                                    "FIB Resolution length";
                                }
                              }  // container via-srv6-sid
    
                              leaf number-of-srv6-carriers {
                                type uint8;
                                description
                                  "Number of SRv6 Carriers";
                              }
    
                              leaf has-srv6-headend-behavior {
                                type boolean;
                                description
                                  "Path has some SRv6 head-end behavior associated";
                              }
    
                              leaf has-via-srv6-sid {
                                type boolean;
                                description
                                  "Via-SRv6-SID is present";
                              }
    
                              list srv6-carrier {
                                description
                                  "List of SRv6 Carriers with one or more SIDs";
                                leaf sid {
                                  type inet:ipv6-address;
                                  description
                                    "SID value";
                                }
                              }  // list srv6-carrier
                            }  // container srv6-info
    
                            leaf address {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type Ipv4-rib-edm-addr;
                              description
                                "Nexthop";
                            }
    
                            leaf information-source {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type Ipv4-rib-edm-addr;
                              description
                                "Infosource";
                            }
    
                            leaf v6-nexthop {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type inet:ipv6-address;
                              description
                                "IPv6 nexthop for v4 over v6";
                            }
    
                            leaf v6-information-source {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type inet:ipv6-address;
                              description
                                "V6 Infosource";
                            }
    
                            leaf interface-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type xr:Interface-name;
                              description
                                "Interface handle for the path's nexthop";
                            }
    
                            leaf metric {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Metrics";
                            }
    
                            leaf load-metric {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Load Metrics";
                            }
    
                            leaf flags64 {
                              type uint64;
                              description
                                "Flags extended to 64 bits";
                            }
    
                            leaf flags {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint16;
                              description
                                "Flags";
                            }
    
                            leaf private-flags {
                              type uint16;
                              description
                                "Private Flags, used internally by RIB";
                            }
    
                            leaf minimum-recurse-length {
                              type uint8;
                              description
                                "Minimum netmask length of recursive resolving
    route";
                            }
    
                            leaf looped {
                              type boolean;
                              description
                                "Looping path";
                            }
    
                            leaf next-hop-table-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "The table to which the next hop belongs";
                            }
    
                            leaf next-hop-vrf-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "VRF Name of the nh table";
                            }
    
                            leaf next-hop-table-name {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "NH table name";
                            }
    
                            leaf next-hop-afi {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NH afi";
                            }
    
                            leaf next-hop-safi {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NH safi";
                            }
    
                            leaf route-label {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Label associated with this path";
                            }
    
                            leaf tunnel-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Tunnel ID associated with this path";
                            }
    
                            leaf pathid {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Path id of this path";
                            }
    
                            leaf backup-pathid {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Path id of this path's backup";
                            }
    
                            leaf ref-cnt-of-backup {
                              type uint32;
                              description
                                "For backup paths, the number of active paths
    protected by the backup path";
                            }
    
                            leaf number-of-extended-communities {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "Number of extended communities associated with
    this path";
                            }
    
                            leaf mvpn-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "MVPN attribute present";
                            }
    
                            leaf path-rt-present {
                              type boolean;
                              description
                                "Path RT present";
                            }
    
                            leaf vrf-import-rt-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "VRFIMPORTRTPresent";
                            }
    
                            leaf source-asrt-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "SOURCEASRTPresent";
                            }
    
                            leaf source-rd-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "SOURCERDPresent";
                            }
    
                            leaf segmented-nexthop-present {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "Segmented NH attributes present for this path";
                            }
    
                            leaf number-of-nnh {
                              type uint32;
                              description
                                "Number of Next Next Hops";
                            }
    
                            leaf next-hop-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "NHID associated with this path";
                            }
    
                            leaf next-hop-id-refcount {
                              type uint32;
                              description
                                "NHID references";
                            }
    
                            leaf ospf-area-id {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type string;
                              description
                                "OSPF area associated with the path";
                            }
    
                            leaf has-labelstk {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type boolean;
                              description
                                "Path has a label stack";
                            }
    
                            leaf num-labels {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint8;
                              description
                                "Number of labels in stack";
                            }
    
                            leaf binding-label {
                              xr:event-telemetry "Subscribe Telemetry Event";
                              type uint32;
                              description
                                "binding Label for this path";
                            }
    
                            leaf nhid-feid {
                              type uint64;
                              description
                                "Fib nhid encap id";
                            }
    
                            leaf mpls-feid {
                              type uint64;
                              description
                                "Fib mpls encap id";
                            }
    
                            leaf has-vxlan-network-id {
                              type boolean;
                              description
                                "VXLAN Network Identifier exists for this path";
                            }
    
                            leaf vxlan-network-id {
                              type uint32;
                              description
                                "VXLAN Network Identifier for this path";
                            }
    
                            leaf has-xcid {
                              type boolean;
                              description
                                "L2 Cross Connect ID exists for this path";
                            }
    
                            leaf xcid {
                              type uint32;
                              description
                                "L2 Cross Connect ID for this path";
                            }
    
                            leaf has-span-diag-interface {
                              type boolean;
                              description
                                "SPAN Diagnostics Interface exists for this path";
                            }
    
                            leaf span-diag-interface {
                              type xr:Interface-name;
                              description
                                "SPAN Diagnostics Interface for this path";
                            }
    
                            leaf has-subscriber-parent-interface {
                              type boolean;
                              description
                                "Subscriber Parent Interface exists for this
    path";
                            }
    
                            leaf subscriber-parent-interface {
                              type xr:Interface-name;
                              description
                                "Subscriber Parent Interface for this path";
                            }
    
                            leaf interface-index-present {
                              type boolean;
                              description
                                "Flag to indicate if interface index attribute
    is present for this path";
                            }
    
                            leaf interface-index-attribute {
                              type uint32;
                              description
                                "Interface Index attribute";
                            }
    
                            leaf iid-present {
                              type boolean;
                              description
                                "Internal ID present";
                            }
    
                            leaf iid {
                              type Ipv4-rib-edm-addr;
                              description
                                "Internal ID attribute";
                            }
    
                            leaf has-l2-info {
                              type boolean;
                              description
                                "L2 Info present for this path";
                            }
    
                            list remote-backup-addr {
                              max-elements 2;
                              description
                                "Remote backup node address";
                              leaf entry {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type Ipv4-rib-edm-addr;
                                description
                                  "Remote backup node address";
                              }
                            }  // list remote-backup-addr
    
                            list labelstk {
                              description
                                "Outgoing label stack for this path";
                              leaf entry {
                                xr:event-telemetry "Subscribe Telemetry Event";
                                type uint32;
                                description
                                  "Outgoing label stack for this path";
                              }
                            }  // list labelstk
    
                            list next-next-hop {
                              description
                                "List of Next Next Hops";
                              leaf type {
                                type Rib-edm-nnh;
                                description
                                  "type";
                              }
    
                              leaf unknownval {
                                when
                                  "../type = 'unknown'" {
                                  description
                                    "../type = 'Unknown'";
                                }
                                type uint32;
                                description
                                  "Unknown Value";
                              }
    
                              leaf address {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../type = 'IPv4Address'";
                                }
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }
    
                              leaf interface-index {
                                when
                                  "../type = 'if-index'" {
                                  description
                                    "../type = 'IfIndex'";
                                }
                                type uint32;
                                description
                                  "Interface Index";
                              }
                            }  // list next-next-hop
                          }  // list ipv4-rib-edm-path
                        }  // container route-path
    
                        leaf prefix {
                          type Ipv4-rib-edm-addr;
                          description
                            "Route prefix";
                        }
    
                        leaf prefix-length-xr {
                          type uint8;
                          description
                            "Length of prefix";
                        }
    
                        leaf route-version {
                          type uint32;
                          description
                            "Route version, incremented by one on each active
    route change";
                        }
    
                        leaf protocol-id {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Protocol advertising the route";
                        }
    
                        leaf protocol-name {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type string;
                          description
                            " Name of Protocol";
                        }
    
                        leaf instance {
                          type string;
                          description
                            "Instance name";
                        }
    
                        leaf client-id {
                          type uint32;
                          description
                            "Client adding the route to RIB";
                        }
    
                        leaf route-type {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint16;
                          description
                            "Type of route installed in RIB";
                        }
    
                        leaf priority {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Route priority";
                        }
    
                        leaf svd-type {
                          type uint8;
                          description
                            "SVD Type of route";
                        }
    
                        leaf l2-route-type {
                          type uint8;
                          description
                            "Type of route associated with L2 Service";
                        }
    
                        leaf flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Route flags";
                        }
    
                        leaf extended-flags {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint64;
                          description
                            "Extended Route flags";
                        }
    
                        leaf tag {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Opaque proto specific info";
                        }
    
                        leaf distance {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Distance of the route";
                        }
    
                        leaf diversion-distance {
                          type uint32;
                          description
                            "Diversion distance of the route";
                        }
    
                        leaf metric {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Route metric";
                        }
    
                        leaf paths-count {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint32;
                          description
                            "Number of paths";
                        }
    
                        leaf attribute-identity {
                          type uint32;
                          description
                            "BGP Attribute ID";
                        }
    
                        leaf traffic-index {
                          type uint8;
                          description
                            "BGP Traffic Index";
                        }
    
                        leaf route-precedence {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "IP precedence for this route";
                        }
    
                        leaf qos-group {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Route qos group";
                        }
    
                        leaf flow-tag {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Flow tag for this route";
                        }
    
                        leaf fwd-class {
                          xr:event-telemetry "Subscribe Telemetry Event";
                          type uint8;
                          description
                            "Forward Class";
                        }
    
                        leaf pic-count {
                          type uint8;
                          description
                            "Number of pic paths in this route";
                        }
    
                        leaf active {
                          type boolean;
                          description
                            "Is the route active or backup";
                        }
    
                        leaf diversion {
                          type boolean;
                          description
                            "Route has a diversion path";
                        }
    
                        leaf diversion-proto-name {
                          type string;
                          description
                            "Diversion route protocol name";
                        }
    
                        leaf route-age {
                          type uint32;
                          units "second";
                          description
                            "Age of route (seconds)";
                        }
    
                        leaf route-label {
                          type uint32;
                          description
                            "Local label of the route";
                        }
    
                        leaf version {
                          type uint32;
                          description
                            "Route Version";
                        }
    
                        leaf tbl-version {
                          type uint64;
                          description
                            "Table Version";
                        }
    
                        leaf route-modify-time {
                          type uint64;
                          units "nanosecond";
                          description
                            "Route modification time(nanoseconds)";
                        }
    
                        leaf prefix-feid {
                          type uint64;
                          description
                            "Fib per-prefix encap id";
                        }
    
                        leaf number-of-algorithm-labels {
                          type uint16;
                          description
                            "Number of Algorithm Labels associated with this
    prefix";
                        }
    
                        list algorithm-label {
                          description
                            "List of Algorithm Labels associated with this
    Prefix";
                          leaf algorithm-id {
                            type uint8;
                            description
                              "Algorithm Identifier";
                          }
    
                          leaf label {
                            type uint32;
                            description
                              "Local label";
                          }
    
                          leaf metric {
                            type uint32;
                            description
                              "Route Metric associated with Algorithm
    Identifier";
                          }
                        }  // list algorithm-label
                      }  // container resolved-route
    
                      leaf prefix {
                        type Ipv4-rib-edm-addr;
                        description
                          "Route prefix";
                      }
    
                      leaf prefix-len {
                        type uint32;
                        description
                          "Length of prefix";
                      }
    
                      leaf dest-addr {
                        type Ipv4-rib-edm-addr;
                        description
                          "Destination address";
                      }
    
                      leaf dest-intf {
                        type uint32;
                        description
                          "Destination interface";
                      }
    
                      leaf dest-tableid {
                        type uint32;
                        description
                          "Destination tableid";
                      }
    
                      leaf dest-metric {
                        type uint32;
                        description
                          "Destination metric";
                      }
    
                      leaf dest-vrf-name {
                        type string;
                        description
                          "VRF Name of the nh table";
                      }
    
                      leaf damped {
                        type boolean;
                        description
                          "Nexthop being damped?";
                      }
    
                      leaf exact-match-xr {
                        type boolean;
                        description
                          "Exact match";
                      }
    
                      leaf allow-default-xr {
                        type boolean;
                        description
                          "Allow default flag";
                      }
    
                      leaf recurse-xr {
                        type boolean;
                        description
                          "Allow recurse flag";
                      }
    
                      leaf xtable {
                        type boolean;
                        description
                          "Cross table nexthop";
                      }
    
                      leaf pack-sf-xr {
                        type boolean;
                        description
                          "Pack SFS paths for multicast";
                      }
    
                      leaf pack-backup {
                        type boolean;
                        description
                          "Pack backup paths";
                      }
    
                      leaf backup-route-xr {
                        type boolean;
                        description
                          "Backup route notifications";
                      }
    
                      leaf best-metric-xr {
                        type boolean;
                        description
                          "Return lowest metric for dest. metric";
                      }
    
                      leaf unres-nh-tree {
                        type boolean;
                        description
                          "Context about which tree the server should walk";
                      }
    
                      leaf flags {
                        type uint16;
                        description
                          "nh_entry flags";
                      }
    
                      leaf dest-path-count {
                        type uint32;
                        description
                          "Number of destination paths";
                      }
    
                      leaf accrued-penalty {
                        type uint16;
                        description
                          "Damped accured penalty";
                      }
    
                      leaf expiration-age {
                        type uint32;
                        description
                          "How soon the nexthop is undamped";
                      }
    
                      leaf expiration-time {
                        type uint64;
                        description
                          "Time where the first is undamped";
                      }
    
                      leaf min-damped-threshold {
                        type uint32;
                        description
                          "Minimum damped threshold";
                      }
    
                      leaf max-damped-penalty {
                        type uint32;
                        description
                          "Maximum damped threshold";
                      }
    
                      leaf decay-rate {
                        type uint32;
                        description
                          "Damped decay rate";
                      }
    
                      leaf version {
                        type uint32;
                        description
                          "Event version";
                      }
    
                      leaf last-event-age {
                        type uint32;
                        description
                          "How long since last event occured";
                      }
    
                      leaf last-event-time {
                        type uint64;
                        description
                          "Time at which last event occured";
                      }
    
                      list dest-path {
                        description
                          "Path(s) of the route";
                        leaf interface {
                          type uint32;
                          description
                            "interface";
                        }
    
                        leaf address {
                          type Ipv4-rib-edm-addr;
                          description "Address";
                        }
    
                        leaf tableid {
                          type uint32;
                          description "tableid";
                        }
    
                        leaf vrf-name {
                          type string;
                          description
                            "VRF Name of the nh table";
                        }
                      }  // list dest-path
                    }  // list rib-nexthop-route
                  }  // container rib-nexthop-routes
    
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description "Route Address ";
                  }
    
                  leaf prefix-length {
                    type xr:Ipv4-prefix-length;
                    description "Prefix Length ";
                  }
    
                  leaf unresolved-nh-tree {
                    type boolean;
                    description
                      "Unresolved Nexthop Tree";
                  }
                }  // list rib-nexthop-prefix
              }  // container rib-nexthop-prefixes
    
              container nexthops-summary {
                description "Nexthops summary";
                leaf num-resolved-nh {
                  type uint32;
                  description
                    "Number of resolved nexthop";
                }
    
                leaf num-unresolved-nh {
                  type uint32;
                  description
                    "Number of unresolved nexthop";
                }
              }  // container nexthops-summary
    
              leaf tableid {
                type xr:Hex-integer;
                description "Table ID";
              }
            }  // list rib-table-id
          }  // container rib-table-ids
    
          container rib-rpfs {
            description "Route prefix table";
            list rib-rpf {
              key "table-id";
              description "Table Id";
              container rib-rpf-list-routes {
                description
                  "rpf list table route";
                list rib-rpf-list-route {
                  description
                    "Last route prefix and prefix length";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description "Route Address ";
                  }
    
                  leaf prefix-length {
                    type xr:Ipv4-prefix-length;
                    description "Prefix Length ";
                  }
    
                  leaf label {
                    type uint32;
                    description "label";
                  }
    
                  leaf flags {
                    type uint32;
                    description "flags";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf sent-to-fib {
                    type boolean;
                    description "sent to fib";
                  }
    
                  list nbr {
                    description "nbr";
                    leaf afi {
                      type uint8;
                      description "afi";
                    }
    
                    leaf ip-address {
                      type Ipv4-rib-edm-addr;
                      description "ip address";
                    }
                  }  // list nbr
                }  // list rib-rpf-list-route
              }  // container rib-rpf-list-routes
    
              container rib-rpf-list-summary-head-counts {
                description
                  "rpf list table summary";
                list rib-rpf-list-summary-head-count {
                  key "rpf-head-count";
                  description "RPF Head count";
                  leaf rpf-head-count {
                    type Rpf-head-count-range;
                    description "RPF Head count";
                  }
    
                  leaf label {
                    type uint32;
                    description "label";
                  }
    
                  leaf flags {
                    type uint32;
                    description "flags";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf sent-to-fib {
                    type boolean;
                    description "sent to fib";
                  }
    
                  list nbr {
                    description "nbr";
                    leaf afi {
                      type uint8;
                      description "afi";
                    }
    
                    leaf ip-address {
                      type Ipv4-rib-edm-addr;
                      description "ip address";
                    }
                  }  // list nbr
                }  // list rib-rpf-list-summary-head-count
              }  // container rib-rpf-list-summary-head-counts
    
              leaf table-id {
                type Table-id-range-ipv4;
                description "Table ID";
              }
            }  // list rib-rpf
          }  // container rib-rpfs
    
          container rib-nh-id-summaries {
            description "NHIds table";
            list rib-nh-id-summary {
              key "table-id";
              description "Table Id";
              container rib-nh-ids {
                description "nhids summary";
                list rib-nh-id {
                  key "nh-id-entry-count";
                  description "NH Id";
                  leaf nh-id-entry-count {
                    type Nhid-entry-count-range;
                    description
                      "NH Id entry count";
                  }
    
                  leaf nhid {
                    type uint32;
                    description "nhid";
                  }
    
                  leaf feid {
                    type uint64;
                    description "feid";
                  }
    
                  leaf nh-addr {
                    type Ipv4-rib-edm-addr;
                    description "nh addr";
                  }
    
                  leaf ifindex {
                    type xr:Interface-name;
                    description "ifindex";
                  }
    
                  leaf chkpt-obj-id {
                    type uint32;
                    description "chkpt obj id";
                  }
    
                  leaf ref-count {
                    type uint32;
                    description "ref count";
                  }
    
                  leaf feature-type {
                    type uint8;
                    description "feature type";
                  }
                }  // list rib-nh-id
              }  // container rib-nh-ids
    
              leaf table-id {
                type Table-id-range-ipv4;
                description "Table Id";
              }
            }  // list rib-nh-id-summary
          }  // container rib-nh-id-summaries
    
          container rib-stats {
            description "Statistics summary";
            container rib-stats-summary {
              description "Summary";
              container batch-stats {
                description "batch stats";
                leaf total-msg-rx {
                  type uint32;
                  description "total msg rx";
                }
    
                leaf route-op-arg-rx {
                  type uint32;
                  description "route op arg rx";
                }
    
                leaf attribute-arg-rx {
                  type uint32;
                  description "attribute arg rx";
                }
    
                leaf complete-arg-rx {
                  type uint32;
                  description "complete arg rx";
                }
    
                leaf converge-arg-rx {
                  type uint32;
                  description "converge arg rx";
                }
    
                leaf opaque-arg-rx {
                  type uint32;
                  description "opaque arg rx";
                }
    
                leaf total-fwd-ref {
                  type uint32;
                  description "total fwd ref";
                }
    
                leaf invalid-client-id-error {
                  type uint32;
                  description
                    "invalid client id error";
                }
    
                leaf mem-alloc-error {
                  type uint32;
                  description "mem alloc error";
                }
    
                leaf client-lookup-error {
                  type uint32;
                  description
                    "client lookup error";
                }
    
                leaf db-lookup-error {
                  type uint32;
                  description "db lookup error";
                }
    
                leaf proto-lookup-error {
                  type uint32;
                  description
                    "proto lookup error";
                }
    
                leaf client-proto-lookup-error {
                  type uint32;
                  description
                    "client proto lookup error";
                }
    
                leaf table-missing-error {
                  type uint32;
                  description
                    "table missing error";
                }
    
                leaf unknown-arg {
                  type uint32;
                  description "unknown arg";
                }
    
                leaf success {
                  type uint32;
                  description "success";
                }
    
                leaf last-result {
                  type uint32;
                  description "last result";
                }
    
                leaf last-operation {
                  type uint32;
                  description "last operation";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-msg-rx-time {
                  type uint64;
                  description "last msg rx time";
                }
              }  // container batch-stats
    
              container lwm-stats {
                description "lwm stats";
                leaf total-lwm {
                  type uint32;
                  description "total lwm";
                }
    
                leaf route-add {
                  type uint32;
                  description "route add";
                }
    
                leaf route-delete {
                  type uint32;
                  description "route delete";
                }
    
                leaf purge-protocol {
                  type uint32;
                  description "purge protocol";
                }
    
                leaf purge-client {
                  type uint32;
                  description "purge client";
                }
    
                leaf protocol-register {
                  type uint32;
                  description
                    "protocol register";
                }
    
                leaf protocol-unregister {
                  type uint32;
                  description
                    "protocol unregister";
                }
    
                leaf protocol-modify {
                  type uint32;
                  description "protocol modify";
                }
    
                leaf redist-proto {
                  type uint32;
                  description "redist proto";
                }
    
                leaf unreg-redist-proto {
                  type uint32;
                  description
                    "unreg redist proto";
                }
    
                leaf redist-reset {
                  type uint32;
                  description "redist reset";
                }
    
                leaf update-complete {
                  type uint32;
                  description "update complete";
                }
    
                leaf advertisement {
                  type uint32;
                  description "advertisement";
                }
    
                leaf unreg-advertisement {
                  type uint32;
                  description
                    "unreg advertisement";
                }
    
                leaf next-hop-register {
                  type uint32;
                  description
                    "next hop register";
                }
    
                leaf next-hop-unregister {
                  type uint32;
                  description
                    "next hop unregister";
                }
    
                leaf bind-data {
                  type uint32;
                  description "bind data";
                }
    
                leaf succcess {
                  type uint32;
                  description "succcess";
                }
    
                leaf route-lookup {
                  type uint32;
                  description "route lookup";
                }
    
                leaf best-local-addr {
                  type uint32;
                  description "best local addr";
                }
    
                leaf is-connected {
                  type uint32;
                  description "is connected";
                }
    
                leaf first-hop {
                  type uint32;
                  description "first hop";
                }
    
                leaf find-proto {
                  type uint32;
                  description "find proto";
                }
    
                leaf free-all-srv6-sid {
                  type uint32;
                  description
                    "free all srv6 sid";
                }
    
                leaf other {
                  type uint32;
                  description "other";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-operation {
                  type uint32;
                  description "last operation";
                }
    
                leaf last-oper-result {
                  type boolean;
                  description "last oper result";
                }
    
                leaf last-lwm-time {
                  type uint64;
                  description "last lwm time";
                }
              }  // container lwm-stats
    
              container nh-batch-stats {
                description "nh batch stats";
                leaf total-nh-batch-requests {
                  type uint32;
                  description
                    "total nh batch requests";
                }
    
                leaf total-nh-operations {
                  type uint32;
                  description
                    "total nh operations";
                }
    
                leaf batch-init {
                  type uint32;
                  description "batch init";
                }
    
                leaf batch-register {
                  type uint32;
                  description "batch register";
                }
    
                leaf batch-unregister {
                  type uint32;
                  description "batch unregister";
                }
    
                leaf register-complete {
                  type uint32;
                  description
                    "register complete";
                }
    
                leaf sync-register {
                  type uint32;
                  description "sync register";
                }
    
                leaf batch-finish {
                  type uint32;
                  description "batch finish";
                }
    
                leaf batch-null {
                  type uint32;
                  description "batch null";
                }
    
                leaf success {
                  type uint32;
                  description "success";
                }
    
                leaf last-client {
                  type uint32;
                  description "last client";
                }
    
                leaf last-nh-operation {
                  type uint32;
                  description
                    "last nh operation";
                }
    
                leaf last-result {
                  type boolean;
                  description "last result";
                }
    
                leaf last-nh-time {
                  type uint64;
                  description "last nh time";
                }
              }  // container nh-batch-stats
    
              container grid-stats {
                description "grid stats";
                leaf num-in-queue {
                  type uint32;
                  description "num in queue";
                }
    
                leaf num-enqueue {
                  type uint32;
                  description "num enqueue";
                }
    
                leaf num-dequeue {
                  type uint32;
                  description "num dequeue";
                }
    
                leaf num-enqueue-del-skipped {
                  type uint32;
                  description
                    "num enqueue del skipped";
                }
    
                leaf num-requeue {
                  type uint32;
                  description "num requeue";
                }
              }  // container grid-stats
            }  // container rib-stats-summary
          }  // container rib-stats
    
          container rib-max-depth {
            description
              "Information of maximum recursion depth in RIB";
            leaf current {
              type uint32;
              description
                "Current maximum recursion depth";
            }
    
            leaf configured {
              type uint32;
              description
                "Configured maximum recursion depth";
            }
          }  // container rib-max-depth
    
          container rib-clients {
            description "Client";
            list rib-client {
              key "clientid";
              description "Specific Client";
              container rib-client-redist-stats {
                description
                  "Redist statistics of a specific client";
                container route {
                  description "route";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf update-sent {
                    type uint32;
                    description "update sent";
                  }
    
                  leaf paths-sent {
                    type uint32;
                    description "paths sent";
                  }
    
                  leaf prefixes-deleted {
                    type uint32;
                    description
                      "prefixes deleted";
                  }
    
                  leaf total-advertisment {
                    type uint32;
                    description
                      "total advertisment";
                  }
    
                  leaf last-redist-delete {
                    type boolean;
                    description
                      "last redist delete";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container route
    
                container attr {
                  description "attr";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-tbl-entries {
                    type uint32;
                    description
                      "total tbl entries";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container attr
    
                container srv6 {
                  description "srv6";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container srv6
    
                leaf protocol-name {
                  type string;
                  description
                    " Name of Protocol";
                }
    
                leaf instance {
                  type string;
                  description "Instance name";
                }
    
                list opaque-stat {
                  max-elements 16;
                  description "opaque stat";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-tbl-entries {
                    type uint32;
                    description
                      "total tbl entries";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // list opaque-stat
              }  // container rib-client-redist-stats
    
              container rib-client-stats-client {
                description
                  "Client statistics of a specific client";
                container notification {
                  description "notification";
                  container evt-hist {
                    description "evt hist";
                    leaf evt-class-name {
                      type string;
                      description
                        "Class name string";
                    }
    
                    list evt-entry {
                      description
                        "Array of event entries";
                      leaf evt-timestamp {
                        type string;
                        description
                          "The timestamp of the event";
                      }
    
                      leaf evt-name {
                        type string;
                        description "Event name";
                      }
    
                      leaf evt-type {
                        type uint8;
                        description "Event type";
                      }
    
                      leaf evt-many {
                        type boolean;
                        description
                          "Multiple instance flag";
                      }
    
                      leaf evt-sticky {
                        type boolean;
                        description
                          "Sticky flag";
                      }
    
                      list evt-data {
                        description
                          "Optional data";
                        leaf entry {
                          type uint32;
                          description
                            "Optional data";
                        }
                      }  // list evt-data
                    }  // list evt-entry
                  }  // container evt-hist
    
                  leaf total-notifications {
                    type uint32;
                    description
                      "total notifications";
                  }
    
                  leaf clear {
                    type uint32;
                    description "clear";
                  }
    
                  leaf nexthop-critical {
                    type uint32;
                    description
                      "nexthop critical";
                  }
    
                  leaf nexthop-noncritical {
                    type uint32;
                    description
                      "nexthop noncritical";
                  }
    
                  leaf nexthop-converge {
                    type uint32;
                    description
                      "nexthop converge";
                  }
    
                  leaf redist-register {
                    type uint32;
                    description
                      "redist register";
                  }
    
                  leaf redist-reset {
                    type uint32;
                    description "redist reset";
                  }
    
                  leaf preceeding-client {
                    type uint32;
                    description
                      "preceeding client";
                  }
    
                  leaf redist-list {
                    type uint32;
                    description "redist list";
                  }
    
                  leaf gc-proto {
                    type uint32;
                    description "gc proto";
                  }
    
                  leaf gc-db {
                    type uint32;
                    description "gc db";
                  }
    
                  leaf gc-attribute {
                    type uint32;
                    description "gc attribute";
                  }
    
                  leaf table-event {
                    type uint32;
                    description "table event";
                  }
    
                  leaf feedback-cookie {
                    type uint32;
                    description
                      "feedback cookie";
                  }
    
                  leaf fib-ug-update {
                    type uint32;
                    description "fib ug update";
                  }
    
                  leaf critical {
                    type uint32;
                    description "critical";
                  }
    
                  leaf non-critical {
                    type uint32;
                    description "non critical";
                  }
    
                  leaf delay-timer {
                    type uint32;
                    description "delay timer";
                  }
    
                  leaf skip-notification {
                    type uint32;
                    description
                      "skip notification";
                  }
    
                  leaf end-of-data {
                    type uint32;
                    description "end of data";
                  }
    
                  leaf disconnect {
                    type uint32;
                    description "disconnect";
                  }
    
                  leaf srv6-redist-register {
                    type uint32;
                    description
                      "srv6 redist register";
                  }
    
                  leaf srv6-cfg-updt {
                    type uint32;
                    description "srv6 cfg updt";
                  }
    
                  leaf srv6-opcode-updt {
                    type uint32;
                    description
                      "srv6 opcode updt";
                  }
    
                  leaf state-sync-done {
                    type uint32;
                    description
                      "state sync done";
                  }
    
                  leaf last-notification {
                    type uint64;
                    description
                      "last notification";
                  }
    
                  leaf last-eod {
                    type uint64;
                    description "last eod";
                  }
    
                  leaf total-pulse {
                    type uint64;
                    description "total pulse";
                  }
    
                  leaf total-select {
                    type uint64;
                    description "total select";
                  }
    
                  leaf total-read {
                    type uint64;
                    description "total read";
                  }
                }  // container notification
    
                container redist {
                  description "redist";
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
                }  // container redist
    
                container tbl-stats {
                  description "tbl stats";
                  leaf total-table-register {
                    type uint32;
                    description
                      "total table register";
                  }
    
                  leaf new-table {
                    type uint32;
                    description "new table";
                  }
    
                  leaf modification {
                    type uint32;
                    description "modification";
                  }
    
                  leaf deletion {
                    type uint32;
                    description "deletion";
                  }
    
                  leaf cl-lookup-err {
                    type uint32;
                    description "cl lookup err";
                  }
    
                  leaf tbl-lookup-err {
                    type uint32;
                    description "tbl lookup err";
                  }
    
                  leaf invalid-id-lookup-err {
                    type uint32;
                    description
                      "invalid id lookup err";
                  }
    
                  leaf tbl-create-err {
                    type uint32;
                    description "tbl create err";
                  }
    
                  leaf success {
                    type uint32;
                    description "success";
                  }
    
                  leaf last-result {
                    type boolean;
                    description "last result";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // container tbl-stats
    
                container redist-tbl {
                  description "redist tbl";
                  leaf total-table-redist {
                    type uint32;
                    description
                      "total table redist";
                  }
    
                  leaf table-created {
                    type uint32;
                    description "table created";
                  }
    
                  leaf table-full {
                    type uint32;
                    description "table full";
                  }
    
                  leaf has-space {
                    type uint32;
                    description "has space";
                  }
    
                  leaf last-redist {
                    type uint8;
                    description "last redist";
                  }
    
                  leaf last-redist-time {
                    type uint64;
                    description
                      "last redist time";
                  }
                }  // container redist-tbl
    
                container attribute {
                  description "attribute";
                  leaf total-registration {
                    type uint32;
                    description
                      "total registration";
                  }
    
                  leaf total-add {
                    type uint32;
                    description "total add";
                  }
    
                  leaf success {
                    type uint32;
                    description "success";
                  }
    
                  leaf last-result {
                    type boolean;
                    description "last result";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // container attribute
    
                container lookups {
                  description "lookups";
                  leaf best-local-address {
                    type uint32;
                    description
                      "best local address";
                  }
    
                  leaf is-connected {
                    type uint32;
                    description "is connected";
                  }
    
                  leaf route-lookups {
                    type uint32;
                    description "route lookups";
                  }
    
                  leaf next-hop-lookups {
                    type uint32;
                    description
                      "next hop lookups";
                  }
    
                  leaf default-source {
                    type uint32;
                    description "default source";
                  }
                }  // container lookups
    
                container fib-ug {
                  description "fib ug";
                  leaf fib-ug-updates {
                    type uint32;
                    description "fib ug updates";
                  }
    
                  leaf fib-ug-total-nodes {
                    type uint32;
                    description
                      "fib ug total nodes";
                  }
                }  // container fib-ug
    
                container ug-start-stats {
                  description "ug start stats";
                  leaf bcdl-ug-notify-num-not-started {
                    type uint32;
                    description
                      "bcdl ug notify num not started";
                  }
    
                  leaf bcdl-ug-last-notify-not-started-time {
                    type uint64;
                    description
                      "bcdl ug last notify not started time";
                  }
                }  // container ug-start-stats
    
                leaf client-id {
                  type uint32;
                  description "client id";
                }
              }  // container rib-client-stats-client
    
              container rib-client-stats {
                description
                  "Statistics of table of a specific client";
                list rib-client-stat {
                  key "table-id";
                  description "Specific Table";
                  container rib-client-stats-protos {
                    description
                      "Statistics of table of protocol of a
    specific client";
                    list rib-client-stats-proto {
                      key "proto-id";
                      description
                        "Specific proto id";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      container route-op-stats {
                        description
                          "route op stats";
                        leaf paths-add-op {
                          type uint32;
                          description
                            "paths add op";
                        }
    
                        leaf prefix-added {
                          type uint32;
                          description
                            "prefix added";
                        }
    
                        leaf paths-added {
                          type uint32;
                          description
                            "paths added";
                        }
    
                        leaf prefix-modified-add {
                          type uint32;
                          description
                            "prefix modified add";
                        }
    
                        leaf paths-delete-op {
                          type uint32;
                          description
                            "paths delete op";
                        }
    
                        leaf prefix-deleted {
                          type uint32;
                          description
                            "prefix deleted";
                        }
    
                        leaf paths-deleted {
                          type uint32;
                          description
                            "paths deleted";
                        }
    
                        leaf prefix-modified-del {
                          type uint32;
                          description
                            "prefix modified del";
                        }
    
                        leaf prefix-flushed {
                          type uint32;
                          description
                            "prefix flushed";
                        }
    
                        leaf paths-flushed {
                          type uint32;
                          description
                            "paths flushed";
                        }
    
                        leaf invalid-op {
                          type uint32;
                          description
                            "invalid op";
                        }
    
                        leaf flushed {
                          type uint32;
                          description "flushed";
                        }
    
                        leaf too-manypaths {
                          type uint32;
                          description
                            "too manypaths";
                        }
    
                        leaf invalid-parameter {
                          type uint32;
                          description
                            "invalid parameter";
                        }
    
                        leaf no-ecmp-support {
                          type uint32;
                          description
                            "no ecmp support";
                        }
    
                        leaf mem-alloc-error {
                          type uint32;
                          description
                            "mem alloc error";
                        }
    
                        leaf path-backup {
                          type uint32;
                          description
                            "path backup";
                        }
    
                        leaf path-active {
                          type uint32;
                          description
                            "path active";
                        }
    
                        leaf path-change {
                          type uint32;
                          description
                            "path change";
                        }
    
                        leaf path-nochange {
                          type uint32;
                          description
                            "path nochange";
                        }
    
                        leaf table-limit {
                          type uint32;
                          description
                            "table limit";
                        }
    
                        leaf outsync {
                          type uint32;
                          description "outsync";
                        }
    
                        leaf last-outsync {
                          type uint64;
                          description
                            "last outsync";
                        }
    
                        leaf last-route-opt {
                          type uint16;
                          description
                            "last route opt";
                        }
    
                        leaf last-result {
                          type uint32;
                          description
                            "last result";
                        }
    
                        leaf last-opt-time {
                          type uint64;
                          description
                            "last opt time";
                        }
    
                        leaf attribute-not-found {
                          type uint32;
                          description
                            "attribute not found";
                        }
    
                        leaf last-attribute-not-found-time {
                          type uint64;
                          description
                            "last attribute not found time";
                        }
    
                        leaf num-fb-cookies {
                          type uint32;
                          description
                            "num fb cookies";
                        }
    
                        leaf last-fb-cookie-op {
                          type uint64;
                          description
                            "last fb cookie op";
                        }
    
                        leaf invalid-path-combination {
                          type uint32;
                          description
                            "invalid path combination";
                        }
    
                        leaf invalid-pathid-change {
                          type uint32;
                          description
                            "invalid pathid change";
                        }
    
                        leaf path-attribute-too-large {
                          type uint32;
                          description
                            "path attribute too large";
                        }
                      }  // container route-op-stats
    
                      container adv {
                        description "adv";
                        leaf total-adv {
                          type uint32;
                          description
                            "total adv";
                        }
    
                        leaf new-adv {
                          type uint32;
                          description "new adv";
                        }
    
                        leaf modification {
                          type uint32;
                          description
                            "modification";
                        }
    
                        leaf delete {
                          type uint32;
                          description "delete";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-result {
                          type boolean;
                          description
                            "last result";
                        }
    
                        leaf last-adv-time {
                          type uint64;
                          description
                            "last adv time";
                        }
                      }  // container adv
    
                      container complete-stats {
                        description
                          "complete stats";
                        leaf total-complete {
                          type uint32;
                          description
                            "total complete";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf last-complete-msg {
                          type uint64;
                          description
                            "last complete msg";
                        }
                      }  // container complete-stats
    
                      container converge-stats {
                        description
                          "converge stats";
                        leaf total-converge {
                          type uint32;
                          description
                            "total converge";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf bad-args {
                          type uint32;
                          description "bad args";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-converge-msg {
                          type uint64;
                          description
                            "last converge msg";
                        }
                      }  // container converge-stats
    
                      container complete-update-stats {
                        description
                          "complete update stats";
                        leaf total-complete {
                          type uint32;
                          description
                            "total complete";
                        }
    
                        leaf insync {
                          type uint32;
                          description "insync";
                        }
    
                        leaf last-insync {
                          type uint64;
                          description
                            "last insync";
                        }
    
                        leaf bad-args {
                          type uint32;
                          description "bad args";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-complete-msg {
                          type uint64;
                          description
                            "last complete msg";
                        }
                      }  // container complete-update-stats
    
                      container purge-stats {
                        description
                          "purge stats";
                        leaf total-purges {
                          type uint32;
                          description
                            "total purges";
                        }
    
                        leaf total-prefix-deleted {
                          type uint32;
                          description
                            "total prefix deleted";
                        }
    
                        leaf total-paths-deleted {
                          type uint32;
                          description
                            "total paths deleted";
                        }
    
                        leaf last-purge {
                          type uint64;
                          description
                            "last purge";
                        }
                      }  // container purge-stats
    
                      container nh-stats {
                        description "nh stats";
                        leaf table-id-xr {
                          type uint32;
                          description
                            "table id xr";
                        }
    
                        leaf vrf-name {
                          type string;
                          description "vrf name";
                        }
    
                        leaf total-next-hop-reg {
                          type uint32;
                          description
                            "total next hop reg";
                        }
    
                        leaf total-next-hop-unreg {
                          type uint32;
                          description
                            "total next hop unreg";
                        }
    
                        leaf total-sync-reg {
                          type uint32;
                          description
                            "total sync reg";
                        }
    
                        leaf last-registration {
                          type uint64;
                          description
                            "last registration";
                        }
                      }  // container nh-stats
    
                      leaf protocol-name {
                        type string;
                        description
                          " Name of Protocol";
                      }
    
                      leaf instance {
                        type string;
                        description
                          "Instance name";
                      }
    
                      list opaque-stat {
                        max-elements 16;
                        description
                          "opaque stat";
                        leaf total-registration {
                          type uint32;
                          description
                            "total registration";
                        }
    
                        leaf total-add {
                          type uint32;
                          description
                            "total add";
                        }
    
                        leaf success {
                          type uint32;
                          description "success";
                        }
    
                        leaf last-result {
                          type boolean;
                          description
                            "last result";
                        }
    
                        leaf last-registration {
                          type uint64;
                          description
                            "last registration";
                        }
                      }  // list opaque-stat
                    }  // list rib-client-stats-proto
                  }  // container rib-client-stats-protos
    
                  leaf table-id {
                    type xr:Cisco-ios-xr-string;
                    description "Table Id";
                  }
                }  // list rib-client-stat
              }  // container rib-client-stats
    
              container rib-client-stats-nexthops {
                description
                  "Statistics of table of a specific client";
                list rib-client-stats-nexthop {
                  key "table-id";
                  description "Specific Table";
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
    
                  leaf table-id-xr {
                    type uint32;
                    description "table id xr";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "vrf name";
                  }
    
                  leaf total-next-hop-reg {
                    type uint32;
                    description
                      "total next hop reg";
                  }
    
                  leaf total-next-hop-unreg {
                    type uint32;
                    description
                      "total next hop unreg";
                  }
    
                  leaf total-sync-reg {
                    type uint32;
                    description "total sync reg";
                  }
    
                  leaf last-registration {
                    type uint64;
                    description
                      "last registration";
                  }
                }  // list rib-client-stats-nexthop
              }  // container rib-client-stats-nexthops
    
              container rib-client-proto {
                description
                  "Information of protocols of client";
                container rib-client-proto-table-ids {
                  description
                    "Client Protocol table";
                  list rib-client-proto-table-id {
                    key "tableid";
                    description
                      "Table ID for a given protocol under a given
    client";
                    container rib-client-proto-ids {
                      description
                        "Protocols list under a given table under a
    given client";
                      list rib-client-proto-id {
                        key "protoid";
                        description
                          "Information of protocols under a given
    table under a given client";
                        leaf protoid {
                          type uint32 {
                            range "0..96";
                          }
                          description "Proto ID";
                        }
    
                        leaf protocol-names {
                          type string;
                          description
                            "Name of proto";
                        }
    
                        leaf proto-instance {
                          type string;
                          description
                            "Instance of proto";
                        }
    
                        leaf distance {
                          type uint32;
                          description
                            "Route distane for the protocol";
                        }
    
                        leaf maxmetric {
                          type uint32;
                          description
                            "Route metric for the protocol";
                        }
    
                        leaf purgetime {
                          type uint32;
                          description
                            "Route purgetime";
                        }
    
                        leaf update-complete {
                          type boolean;
                          description
                            "Has the client finished updating";
                        }
                      }  // list rib-client-proto-id
                    }  // container rib-client-proto-ids
    
                    container rib-client-proto-table-info {
                      description
                        "Information of a specifc table under a
    given protocol under a given client";
                      leaf num-protos-outsync {
                        type uint32;
                        description
                          "Count of out-of-sync protocols";
                      }
    
                      leaf update-time {
                        type uint64;
                        units "nanosecond";
                        description
                          "Time of last update (nanoseconds)";
                      }
    
                      leaf afi {
                        type uint32;
                        description
                          "Address Family";
                      }
    
                      leaf safi {
                        type uint32;
                        description
                          "sub Address Family";
                      }
    
                      leaf vrf-name {
                        type string;
                        description
                          "VRF Name of the table";
                      }
                    }  // container rib-client-proto-table-info
    
                    leaf tableid {
                      type xr:Cisco-ios-xr-string;
                      description "Table Id";
                    }
                  }  // list rib-client-proto-table-id
                }  // container rib-client-proto-table-ids
    
                container rib-client-proto-info {
                  description
                    "Information of protocols of a specific client";
                  leaf num-protos-outsync {
                    type uint32;
                    description
                      "Count of out-of-sync protocols";
                  }
    
                  leaf update-time {
                    type uint32;
                    units "second";
                    description
                      "Time of last update in seconds";
                  }
                }  // container rib-client-proto-info
              }  // container rib-client-proto
    
              container rib-client-stats-redist-nexthops {
                description
                  "Statistics of nexthop table distribution";
                list rib-client-stats-redist-nexthop {
                  key "table-id";
                  description "Specific Table";
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
    
                  leaf table-id-xr {
                    type uint32;
                    description "table id xr";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "vrf name";
                  }
    
                  leaf total-redist {
                    type uint32;
                    description "total redist";
                  }
    
                  leaf total-converge {
                    type uint32;
                    description "total converge";
                  }
    
                  leaf total-suppress {
                    type uint32;
                    description "total suppress";
                  }
    
                  leaf last-redist {
                    type uint64;
                    description "last redist";
                  }
    
                  leaf total-converge-sent {
                    type uint32;
                    description
                      "total converge sent";
                  }
    
                  leaf last-converge {
                    type uint64;
                    description "last converge";
                  }
    
                  leaf last-converge-sent {
                    type uint64;
                    description
                      "last converge sent";
                  }
                }  // list rib-client-stats-redist-nexthop
              }  // container rib-client-stats-redist-nexthops
    
              container rib-client-info {
                description
                  "Information for a specific client";
                leaf pname {
                  type string;
                  description "Client's name";
                }
    
                leaf nodename {
                  type string;
                  description
                    "Node client process is running on";
                }
    
                leaf pid {
                  type uint32;
                  description
                    "Client's process ID";
                }
    
                leaf redist {
                  type boolean;
                  description
                    "Is client registered for redist";
                }
    
                leaf proto {
                  type boolean;
                  description
                    "Is client registered as a protocol";
                }
    
                leaf client-id {
                  type uint32;
                  description
                    "Client's RIB ID number";
                }
              }  // container rib-client-info
    
              container rib-client-redist-history {
                description
                  "History information of the table associated
    with a given redist under a specific client";
                container routes {
                  description
                    "Link to history routes";
                  list ipv4-rib-edm-client-history-route {
                    description "Next route";
                    container advertisement {
                      description
                        "list of advertising protos";
                      list ipv4-rib-edm-advert {
                        description
                          "Next advertising proto";
                        leaf protocol-id {
                          type uint32;
                          description
                            "Protocol advertising the route";
                        }
    
                        leaf client-id {
                          type uint32;
                          description
                            "  Client advertising the route";
                        }
    
                        leaf number-of-extended-communities {
                          type uint32;
                          description
                            "Number of extended communities attached by
    advertiser";
                        }
    
                        leaf extended-communities {
                          type yang:hex-string;
                          description
                            "Extended communities attached by the advertiser";
                        }
    
                        leaf protocol-opaque-flags {
                          type uint8;
                          description
                            "OSPF area-id flags";
                        }
    
                        leaf protocol-opaque {
                          type uint32;
                          description
                            "OSPF area-id";
                        }
    
                        leaf code {
                          type int8;
                          description
                            "Protocol code";
                        }
    
                        leaf instance-name {
                          type string {
                            length "0..41";
                          }
                          description
                            "Instance name of the protocol advertising the
    route";
                        }
                      }  // list ipv4-rib-edm-advert
                    }  // container advertisement
    
                    leaf prefix {
                      type Ipv4-rib-edm-addr;
                      description "Route prefix";
                    }
    
                    leaf prefix-length {
                      type uint8;
                      description
                        "Length of prefix";
                    }
    
                    leaf priority {
                      type uint8;
                      description
                        "Priority of update";
                    }
    
                    leaf flags {
                      type uint32;
                      description "Route flags";
                    }
    
                    leaf source {
                      type uint32;
                      description "source";
                    }
    
                    leaf table-id {
                      type uint32;
                      description
                        "table identifier";
                    }
    
                    leaf distance {
                      type uint32;
                      description
                        "Administrative distance";
                    }
    
                    leaf metric {
                      type uint32;
                      description "Route metric";
                    }
    
                    leaf local-label {
                      type uint32;
                      description
                        "Route local label";
                    }
    
                    leaf path-num {
                      type uint16;
                      description
                        "Number of paths";
                    }
    
                    leaf nnh-num {
                      type uint16;
                      description
                        "Number of NNHs";
                    }
    
                    leaf route-age {
                      type uint32;
                      units "second";
                      description
                        "Age of event (seconds)";
                    }
    
                    leaf route-modify-time {
                      type uint64;
                      units "nanosecond";
                      description
                        "Time of event (nanoseconds)";
                    }
    
                    leaf private-flags {
                      type uint16;
                      description
                        "Route head private flags";
                    }
    
                    leaf number-of-srv6-sids {
                      type uint16;
                      description
                        "Number of SRv6 Segment Identifiers";
                    }
    
                    leaf converge {
                      type uint8;
                      description
                        "Redist table converged";
                    }
    
                    leaf code {
                      type int8;
                      description
                        "Protocol code";
                    }
    
                    leaf outsync {
                      type uint32;
                      description
                        "Last packed outsync prio";
                    }
                  }  // list ipv4-rib-edm-client-history-route
                }  // container routes
    
                leaf num-tables-outsync {
                  type uint32;
                  description
                    "Num tables to get updates from";
                }
    
                leaf num-history-routes {
                  type uint32;
                  description
                    "Number of history routes";
                }
              }  // container rib-client-redist-history
    
              container rib-client-redists {
                description
                  "RIB client redistribution";
                list rib-client-redist {
                  key "table-id";
                  description
                    "Id of RIB client redistribution Table";
                  container rib-client-redist-protos {
                    description "Client proto";
                    list rib-client-redist-proto {
                      key "proto-id";
                      description
                        "Protocols information for a specific client";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      leaf insync {
                        type boolean;
                        description
                          "Is this in sync or not?";
                      }
    
                      leaf protocol-names {
                        type string;
                        description
                          "Name of proto it is redistributing";
                      }
    
                      leaf proto-instance {
                        type string;
                        description
                          "Instance of redistributed proto";
                      }
    
                      leaf updatemode {
                        type uint32;
                        description
                          "Type of route information getting redistributed";
                      }
                    }  // list rib-client-redist-proto
                  }  // container rib-client-redist-protos
    
                  container rib-client-redist-info {
                    description
                      "Information for a specific redistribution
    table under a given client";
                    leaf full-table {
                      type boolean;
                      description
                        "Full table redistrbution or not?";
                    }
    
                    leaf insync {
                      type uint32;
                      description
                        "Is this is sync or not?";
                    }
    
                    leaf afi {
                      type uint32;
                      description
                        "Address Family";
                    }
    
                    leaf safi {
                      type uint32;
                      description
                        "sub Address Family";
                    }
    
                    leaf vrf-name {
                      type string;
                      description
                        "VRF Name of the table";
                    }
    
                    leaf updatemode {
                      type uint32;
                      description
                        "Update type in route registration";
                    }
                  }  // container rib-client-redist-info
    
                  leaf table-id {
                    type xr:Cisco-ios-xr-string;
                    description "Table Id";
                  }
                }  // list rib-client-redist
              }  // container rib-client-redists
    
              container rib-client-stats-redists {
                description
                  "Statistics of table distribution";
                list rib-client-stats-redist {
                  key "table-id";
                  description "Specific Table";
                  container rib-client-stats-redist-protos {
                    description
                      "Protocol under a given table";
                    list rib-client-stats-redist-proto {
                      key "proto-id";
                      description
                        "Specific protocol";
                      leaf proto-id {
                        type uint32 {
                          range "0..96";
                        }
                        description "Proto ID";
                      }
    
                      container route {
                        description "route";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf update-sent {
                          type uint32;
                          description
                            "update sent";
                        }
    
                        leaf paths-sent {
                          type uint32;
                          description
                            "paths sent";
                        }
    
                        leaf prefixes-deleted {
                          type uint32;
                          description
                            "prefixes deleted";
                        }
    
                        leaf total-advertisment {
                          type uint32;
                          description
                            "total advertisment";
                        }
    
                        leaf last-redist-delete {
                          type boolean;
                          description
                            "last redist delete";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container route
    
                      container attr {
                        description "attr";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf total-tbl-entries {
                          type uint32;
                          description
                            "total tbl entries";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container attr
    
                      container srv6 {
                        description "srv6";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // container srv6
    
                      leaf protocol-name {
                        type string;
                        description
                          " Name of Protocol";
                      }
    
                      leaf instance {
                        type string;
                        description
                          "Instance name";
                      }
    
                      list opaque-stat {
                        max-elements 16;
                        description
                          "opaque stat";
                        leaf total-redist {
                          type uint32;
                          description
                            "total redist";
                        }
    
                        leaf total-tbl-entries {
                          type uint32;
                          description
                            "total tbl entries";
                        }
    
                        leaf last-redist {
                          type uint64;
                          description
                            "last redist";
                        }
                      }  // list opaque-stat
                    }  // list rib-client-stats-redist-proto
                  }  // container rib-client-stats-redist-protos
    
                  leaf table-id {
                    type Table-id-range-ipv4;
                    description "Table Id";
                  }
                }  // list rib-client-stats-redist
              }  // container rib-client-stats-redists
    
              leaf clientid {
                type uint32 {
                  range "0..2501";
                }
                description "Client ID";
              }
            }  // list rib-client
          }  // container rib-clients
        }  // container rib
      }  // module Cisco-IOS-XR-ip-rib-ipv4-oper
    

© 2023 YumaWorks, Inc. All rights reserved.